/*

 * $LynxId: UCAux.c,v 1.51 2016/04/17 22:18:15 tom Exp $

 */

#include <HTUtils.h>

#include <HTCJK.h>

#include <UCMap.h>

#include <UCDefs.h>

#include <HTStream.h>

#include <UCAux.h>

#include <LYCharSets.h>

#include <LYCurses.h>

#include <LYStrings.h>

BOOL UCCanUniTranslateFrom(int from)

{

    if (from < 0)

	return NO;

#ifndef EXP_JAPANESEUTF8_SUPPORT

    if (LYCharSet_UC[from].enc == UCT_ENC_CJK)

	return NO;

#endif

    if (!strcmp(LYCharSet_UC[from].MIMEname, "x-transparent"))

	return NO;

    /* others YES */

    return YES;

}

BOOL UCCanTranslateUniTo(int to)

{

    if (to < 0)

	return NO;

    return YES;			/* well at least some characters... */

}

BOOL UCCanTranslateFromTo(int from,

			  int to)

{

    if (from == to)

	return YES;

    if (from < 0 || to < 0)

	return NO;

    if (from == LATIN1)

	return UCCanTranslateUniTo(to);

    if (to == LATIN1 || LYCharSet_UC[to].enc == UCT_ENC_UTF8)

	return UCCanUniTranslateFrom(from);

    {

	const char *fromname = LYCharSet_UC[from].MIMEname;

	const char *toname = LYCharSet_UC[to].MIMEname;

	if (!strcmp(fromname, "x-transparent") ||

	    !strcmp(toname, "x-transparent")) {

	    return YES;		/* ??? */

	} else if (!strcmp(fromname, "us-ascii")) {

	    return YES;

	}

	if (LYCharSet_UC[from].enc == UCT_ENC_CJK) {

	    /*

	     * CJK mode may be off (i.e., !IS_CJK_TTY) because the current

	     * document is not CJK, but the check may be for capability in

	     * relation to another document, for which CJK mode might be turned

	     * on when retrieved.  Thus, when the from charset is CJK, check if

	     * the to charset is CJK, and return NO or YES in relation to that. 

	     * - FM

	     */

	    if (LYCharSet_UC[to].enc != UCT_ENC_CJK)

		return NO;

	    if ((!strcmp(toname, "euc-jp") ||

		 !strcmp(toname, "shift_jis")) &&

		(!strcmp(fromname, "euc-jp") ||

		 !strcmp(fromname, "shift_jis")))

		return YES;

	    /*

	     * The euc-cn and euc-kr charsets were handled by the (from == to)

	     * above, so we need not check those.  - FM

	     */

	    return NO;

	}

    }

    return YES;			/* others YES */

}

/*

 *  Returns YES if no translation necessary (because

 *  charsets are equal, are equivalent, etc.).

 */

BOOL UCNeedNotTranslate(int from,

			int to)

{

    const char *fromname;

    const char *toname;

    if (from == to)

	return YES;

    if (from < 0)

	return NO;		/* ??? */

    if (LYCharSet_UC[from].enc == UCT_ENC_7BIT) {

	return YES;		/* Only 7bit chars. */

    }

    fromname = LYCharSet_UC[from].MIMEname;

    if (!strcmp(fromname, "x-transparent") ||

	!strcmp(fromname, "us-ascii")) {

	return YES;

    }

    if (to < 0)

	return NO;		/* ??? */

    if (to == LATIN1) {

	if (LYCharSet_UC[from].codepoints & (UCT_CP_SUBSETOF_LAT1))

	    return YES;

    }

    toname = LYCharSet_UC[to].MIMEname;

    if (!strcmp(toname, "x-transparent")) {

	return YES;

    }

    if (LYCharSet_UC[to].enc == UCT_ENC_UTF8) {

	return NO;

    }

    if (from == LATIN1) {

	if (LYCharSet_UC[from].codepoints & (UCT_CP_SUPERSETOF_LAT1))

	    return YES;

    }

    if (LYCharSet_UC[from].enc == UCT_ENC_CJK) {

	if (!IS_CJK_TTY)	/* Use that global flag, for now. */

	    return NO;

	if (HTCJK == JAPANESE &&

	    (!strcmp(fromname, "euc-jp") ||

	     !strcmp(fromname, "shift_jis")))

	    return YES;		/* translate internally by lynx, no unicode */

	return NO;		/* If not handled by (from == to) above. */

    }

    return NO;

}

/*

 *  The idea here is that any stage of the stream pipe which is interested

 *  in some charset dependent processing will call this function.

 *  Given input and output charsets, this function will set various flags

 *  in a UCTransParams structure that _suggest_ to the caller what to do.

 *

 *  Should be called once when a stage starts processing text (and the

 *  input and output charsets are known), or whenever one of input or

 *  output charsets has changed (e.g., by SGML.c stage after HTML.c stage

 *  has processed a META tag).

 *  The global flags (LYRawMode, HTPassEightBitRaw etc.) are currently

 *  not taken into account here (except for HTCJK, somewhat), it's still

 *  up to the caller to do something about them. - KW

 */

void UCSetTransParams(UCTransParams * pT, int cs_in,

		      const LYUCcharset *p_in,

		      int cs_out,

		      const LYUCcharset *p_out)

{

    CTRACE((tfp, "UCSetTransParams: from %s(%d) to %s(%d)\n",

	    p_in->MIMEname, UCGetLYhndl_byMIME(p_in->MIMEname),

	    p_out->MIMEname, UCGetLYhndl_byMIME(p_out->MIMEname)));

    /*

     * Initialize this element to FALSE, and set it TRUE below if we're dealing

     * with VISCII.  - FM

     */

    pT->trans_C0_to_uni = FALSE;

    /*

     * The "transparent" display character set is a "super raw mode".  - FM

     */

    pT->transp = (BOOL) (!strcmp(p_in->MIMEname, "x-transparent") ||

			 !strcmp(p_out->MIMEname, "x-transparent"));

    /*

     * UCS-2 is handled as a special case in SGML_write().

     */

    pT->ucs_mode = 0;

    if (pT->transp) {

	/*

	 * Set up the structure for "transparent".  - FM

	 */

	pT->do_cjk = FALSE;

	pT->decode_utf8 = FALSE;

	pT->output_utf8 = FALSE;	/* We may, but won't know about it. - KW */

	pT->do_8bitraw = TRUE;

	pT->use_raw_char_in = TRUE;

	pT->strip_raw_char_in = FALSE;

	pT->pass_160_173_raw = TRUE;

	pT->repl_translated_C0 = (BOOL) (p_out->enc == UCT_ENC_8BIT_C0);

	pT->trans_C0_to_uni = (BOOL) (p_in->enc == UCT_ENC_8BIT_C0 ||

				      p_out->enc == UCT_ENC_8BIT_C0);

    } else {

	/*

	 * Initialize local flags.  - FM

	 */

	BOOL intm_ucs = FALSE;

	BOOL use_ucs = FALSE;

	/*

	 * Set this element if we want to treat the input as CJK.  - FM

	 */

	pT->do_cjk = (BOOL) ((p_in->enc == UCT_ENC_CJK) && IS_CJK_TTY);

	/*

	 * Set these elements based on whether we are dealing with UTF-8.  - FM

	 */

	pT->decode_utf8 = (BOOL) (p_in->enc == UCT_ENC_UTF8);

	pT->output_utf8 = (BOOL) (p_out->enc == UCT_ENC_UTF8);

	if (pT->do_cjk) {

	    /*

	     * Set up the structure for a CJK input with

	     * a CJK output (IS_CJK_TTY).  - FM

	     */

	    pT->trans_to_uni = FALSE;

	    pT->do_8bitraw = FALSE;

	    pT->pass_160_173_raw = TRUE;

	    pT->use_raw_char_in = FALSE;	/* Not used for CJK. - KW */

	    pT->repl_translated_C0 = FALSE;

	    pT->trans_from_uni = FALSE;		/* Not used for CJK. - KW */

	} else {

	    /*

	     * Set up for all other charset combinations.  The intm_ucs flag is

	     * set TRUE if the input charset is iso-8859-1 or UTF-8, or largely

	     * equivalent to them, i.e., if we have UCS without having to do a

	     * table translation.

	     */

	    intm_ucs = (BOOL) (cs_in == LATIN1 || pT->decode_utf8 ||

			       (p_in->codepoints &

				(UCT_CP_SUBSETOF_LAT1 | UCT_CP_SUBSETOF_UCS2)));

	    /*

	     * pT->trans_to_uni is set TRUE if we do not have that as input

	     * already, and we can translate to Unicode.  Note that UTF-8

	     * always is converted to Unicode in functions that use the

	     * transformation structure, so it is treated as already Unicode

	     * here.

	     */

	    pT->trans_to_uni = (BOOL) (!intm_ucs &&

				       UCCanUniTranslateFrom(cs_in));

	    /*

	     * We set this if we are translating to Unicode and what normally

	     * are low value control characters in fact are encoding octets for

	     * the input charset (presently, this applies to VISCII).  - FM

	     */

	    pT->trans_C0_to_uni = (BOOL) (pT->trans_to_uni &&

					  p_in->enc == UCT_ENC_8BIT_C0);

	    /*

	     * We set this, presently, for VISCII.  - FM

	     */

	    pT->repl_translated_C0 = (BOOL) (p_out->enc == UCT_ENC_8BIT_C0);

	    /*

	     * Currently unused for any charset combination.

	     * Should always be FALSE

	     */

	    pT->strip_raw_char_in = FALSE;

	    /*

	     * use_ucs should be set TRUE if we have or will create Unicode

	     * values for input octets or UTF multibytes.  - FM

	     */

	    use_ucs = (BOOL) (intm_ucs || pT->trans_to_uni);

	    /*

	     * This is set TRUE if use_ucs was set FALSE.  It is complementary

	     * to the HTPassEightBitRaw flag, which is set TRUE or FALSE

	     * elsewhere based on the raw mode setting in relation to the

	     * current Display Character Set.  - FM

	     */

	    pT->do_8bitraw = (BOOL) (!use_ucs);

	    /*

	     * This is set TRUE when 160 and 173 should not be treated as nbsp

	     * and shy, respectively.  - FM

	     */

	    pT->pass_160_173_raw = (BOOL) (!use_ucs &&

					   !(p_in->like8859 & UCT_R_8859SPECL));

	    /*

	     * This is set when the input and output charsets match, and they

	     * are not ones which should go through a Unicode translation

	     * process anyway.  - FM

	     */

	    pT->use_raw_char_in = (BOOL) (!pT->output_utf8 &&

					  cs_in == cs_out &&

					  !pT->trans_C0_to_uni);

	    /*

	     * This should be set TRUE when we expect to have done translation

	     * to Unicode or had the equivalent as input, can translate it to

	     * our output charset, and normally want to do so.  The latter

	     * depends on the pT->do_8bitraw and pT->use_raw_char_in values set

	     * above, but also on HTPassEightBitRaw in any functions which use

	     * the transformation structure..  - FM

	     */

	    pT->trans_from_uni = (BOOL) (use_ucs && !pT->do_8bitraw &&

					 !pT->use_raw_char_in &&

					 UCCanTranslateUniTo(cs_out));

	}

    }

}

/*

 *  This function initializes the transformation

 *  structure by setting all its elements to

 *  FALSE. - KW

 */

void UCTransParams_clear(UCTransParams * pT)

{

    pT->transp = FALSE;

    pT->do_cjk = FALSE;

    pT->decode_utf8 = FALSE;

    pT->output_utf8 = FALSE;

    pT->do_8bitraw = FALSE;

    pT->use_raw_char_in = FALSE;

    pT->strip_raw_char_in = FALSE;

    pT->pass_160_173_raw = FALSE;

    pT->trans_to_uni = FALSE;

    pT->trans_C0_to_uni = FALSE;

    pT->repl_translated_C0 = FALSE;

    pT->trans_from_uni = FALSE;

}

/*

 * If terminal is in UTF-8 mode, it probably cannot understand box drawing

 * chars as the 8-bit (n)curses handles them.  (This may also be true for other

 * display character sets, but isn't currently checked.) In that case set the

 * chars for horizontal and vertical drawing chars to displayable ASCII chars

 * if '0' was requested.  They'll stay as they are otherwise.  -KW, TD

 *

 * If we're able to obtain a character set based on the locale settings,

 * assume that the user has setup $TERM and the fonts already so line-drawing

 * works.

 */

void UCSetBoxChars(int cset,

		   int *pvert_out,

		   int *phori_out,

		   int vert_in,

		   int hori_in)

{

    BOOL fix_lines = FALSE;

    if (cset >= 0) {

#ifndef WIDEC_CURSES

	if (LYCharSet_UC[cset].enc == UCT_ENC_UTF8) {

	    fix_lines = TRUE;

	}

#endif

	/*

	 * If we've identified a charset that works, require it.

	 * This is important if we have loaded a font, which would

	 * confuse curses.

	 */

	/* US-ASCII vs Latin-1 is safe (usually) */

	if ((cset == US_ASCII

	     || cset == LATIN1)

	    && (linedrawing_char_set == US_ASCII

		|| linedrawing_char_set == LATIN1)) {

#if (defined(FANCY_CURSES) && defined(A_ALTCHARSET)) || defined(USE_SLANG)

	    vert_in = 0;

	    hori_in = 0;

#else

	    ;

#endif

	}

#ifdef EXP_CHARTRANS_AUTOSWITCH

#if defined(NCURSES_VERSION) || defined(HAVE_TIGETSTR)

	else {

	    static BOOL first = TRUE;

	    static int last_cset = -99;

	    static BOOL last_result = TRUE;

	    /* *INDENT-OFF* */

	    static struct {

		int mapping;

		UCode_t internal;

		int external;

	    } table[] = {

		{ 'j', 0x2518, 0 }, /* BOX DRAWINGS LIGHT UP AND LEFT */

		{ 'k', 0x2510, 0 }, /* BOX DRAWINGS LIGHT DOWN AND LEFT */

		{ 'l', 0x250c, 0 }, /* BOX DRAWINGS LIGHT DOWN AND RIGHT */

		{ 'm', 0x2514, 0 }, /* BOX DRAWINGS LIGHT UP AND RIGHT */

		{ 'n', 0x253c, 0 }, /* BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL */

		{ 'q', 0x2500, 0 }, /* BOX DRAWINGS LIGHT HORIZONTAL */

		{ 't', 0x251c, 0 }, /* BOX DRAWINGS LIGHT VERTICAL AND RIGHT */

		{ 'u', 0x2524, 0 }, /* BOX DRAWINGS LIGHT VERTICAL AND LEFT */

		{ 'v', 0x2534, 0 }, /* BOX DRAWINGS LIGHT UP AND HORIZONTAL */

		{ 'w', 0x252c, 0 }, /* BOX DRAWINGS LIGHT DOWN AND HORIZONTAL */

		{ 'x', 0x2502, 0 }, /* BOX DRAWINGS LIGHT VERTICAL */

	    };

	    /* *INDENT-ON* */

	    unsigned n;

	    if (first) {

		static char acsc_name[] = "acsc";

		char *map = tigetstr(acsc_name);

		if (map != 0) {

		    CTRACE((tfp, "build terminal line-drawing map\n"));

		    while (map[0] != 0 && map[1] != 0) {

			for (n = 0; n < TABLESIZE(table); ++n) {

			    if (table[n].mapping == map[0]) {

				table[n].external = UCH(map[1]);

				CTRACE((tfp,

					"  map[%c] %#" PRI_UCode_t " -> %#x\n",

					table[n].mapping,

					table[n].internal,

					table[n].external));

				break;

			    }

			}

			map += 2;

		    }

		}

		first = FALSE;

	    }

	    if (cset == last_cset) {

		fix_lines = last_result;

	    } else if (cset == UTF8_handle) {

		last_result = FALSE;

		last_cset = cset;

	    } else {

		CTRACE((tfp, "check terminal line-drawing map\n"));

		for (n = 0; n < TABLESIZE(table); ++n) {

		    int test = UCTransUniChar(table[n].internal, cset);

		    if (test != table[n].external) {

			CTRACE((tfp,

				"line-drawing map %c mismatch (have %#x, want %#x)\n",

				table[n].mapping,

				test, table[n].external));

			fix_lines = TRUE;

			break;

		    }

		}

		last_result = fix_lines;

		last_cset = cset;

	    }

	}

#else

	else if (cset != linedrawing_char_set && linedrawing_char_set >= 0) {

	    fix_lines = TRUE;

	}

#endif

#endif

    }

    if (fix_lines) {

	if (!vert_in)

	    vert_in = '|';

	if (!hori_in)

	    hori_in = '-';

    }

    *pvert_out = vert_in;

    *phori_out = hori_in;

}

/*

 *  Given an output target HTStream* (can also be a HTStructured* via

 *  typecast), the target stream's put_character method, and a Unicode

 *  character,  CPutUtf8_charstring() will either output the UTF8

 *  encoding of the Unicode and return YES, or do nothing and return

 *  NO (if conversion would be unnecessary or the Unicode character is

 *  considered invalid).

 *

 *  [Could be used more generally, but is currently only used for &#nnnnn

 *  stuff - generation of UTF8 from 8-bit encoded charsets not yet done

 *  by SGML.c etc.]

 */

#define PUTC(ch) ((*myPutc)(target, (char)(ch)))

#define PUTC2(ch) ((*myPutc)(target,(char)(0x80|(0x3f &(ch)))))

BOOL UCPutUtf8_charstring(HTStream *target, putc_func_t *myPutc, UCode_t code)

{

    if (code < 128)

	return NO;		/* indicate to caller we didn't handle it */

    else if (code < 0x800L) {

	PUTC(0xc0 | (code >> 6));

	PUTC2(code);

    } else if (code < 0x10000L) {

	PUTC(0xe0 | (code >> 12));

	PUTC2(code >> 6);

	PUTC2(code);

    } else if (code < 0x200000L) {

	PUTC(0xf0 | (code >> 18));

	PUTC2(code >> 12);

	PUTC2(code >> 6);

	PUTC2(code);

    } else if (code < 0x4000000L) {

	PUTC(0xf8 | (code >> 24));

	PUTC2(code >> 18);

	PUTC2(code >> 12);

	PUTC2(code >> 6);

	PUTC2(code);

    } else if (code <= 0x7fffffffL) {

	PUTC(0xfc | (code >> 30));

	PUTC2(code >> 24);

	PUTC2(code >> 18);

	PUTC2(code >> 12);

	PUTC2(code >> 6);

	PUTC2(code);

    } else

	return NO;

    return YES;

}

/*

 *  This function converts a Unicode (UCode_t) value

 *  to a multibyte UTF-8 character, which is loaded

 *  into the buffer received as an argument.  The

 *  buffer should be large enough to hold at least

 *  seven characters (but should be declared as 8

 *  to minimize byte alignment problems with some

 *  compilers). - FM

 */

BOOL UCConvertUniToUtf8(UCode_t code, char *buffer)

{

    char *ch = buffer;

    if (!ch)

	return NO;

    if (code <= 0 || code > 0x7fffffffL) {

	*ch = '\0';

	return NO;

    }

    if (code < 0x800L) {

	*ch++ = (char) (0xc0 | (code >> 6));

	*ch++ = (char) (0x80 | (0x3f & (code)));

	*ch = '\0';

    } else if (code < 0x10000L) {

	*ch++ = (char) (0xe0 | (code >> 12));

	*ch++ = (char) (0x80 | (0x3f & (code >> 6)));

	*ch++ = (char) (0x80 | (0x3f & (code)));

	*ch = '\0';

    } else if (code < 0x200000L) {

	*ch++ = (char) (0xf0 | (code >> 18));

	*ch++ = (char) (0x80 | (0x3f & (code >> 12)));

	*ch++ = (char) (0x80 | (0x3f & (code >> 6)));

	*ch++ = (char) (0x80 | (0x3f & (code)));

	*ch = '\0';

    } else if (code < 0x4000000L) {

	*ch++ = (char) (0xf8 | (code >> 24));

	*ch++ = (char) (0x80 | (0x3f & (code >> 18)));

	*ch++ = (char) (0x80 | (0x3f & (code >> 12)));

	*ch++ = (char) (0x80 | (0x3f & (code >> 6)));

	*ch++ = (char) (0x80 | (0x3f & (code)));

	*ch = '\0';

    } else {

	*ch++ = (char) (0xfc | (code >> 30));

	*ch++ = (char) (0x80 | (0x3f & (code >> 24)));

	*ch++ = (char) (0x80 | (0x3f & (code >> 18)));

	*ch++ = (char) (0x80 | (0x3f & (code >> 12)));

	*ch++ = (char) (0x80 | (0x3f & (code >> 6)));

	*ch++ = (char) (0x80 | (0x3f & (code)));

	*ch = '\0';

    }

    return YES;

}

/*

 * Get UCS character code for one character from UTF-8 encoded string.

 *

 * On entry:

 *	*ppuni should point to beginning of UTF-8 encoding character

 * On exit:

 *	*ppuni is advanced to point to the last byte of UTF-8 sequence,

 *		if there was a valid one; otherwise unchanged.

 * returns the UCS value

 * returns negative value on error (invalid UTF-8 sequence)

 */

UCode_t UCGetUniFromUtf8String(const char **ppuni)

{

    UCode_t uc_out = 0;

    const char *p = *ppuni;

    int utf_count, i;

    if (!(**ppuni & 0x80))

	return (UCode_t) **ppuni;	/* ASCII range character */

    else if (!(**ppuni & 0x40))

	return (-1);		/* not a valid UTF-8 start */

    if ((*p & 0xe0) == 0xc0) {

	utf_count = 1;

    } else if ((*p & 0xf0) == 0xe0) {

	utf_count = 2;

    } else if ((*p & 0xf8) == 0xf0) {

	utf_count = 3;

    } else if ((*p & 0xfc) == 0xf8) {

	utf_count = 4;

    } else if ((*p & 0xfe) == 0xfc) {

	utf_count = 5;

    } else {			/* garbage */

	return (-1);

    }

    for (p = *ppuni, i = 0; i < utf_count; i++) {

	if ((*(++p) & 0xc0) != 0x80)

	    return (-1);

    }

    p = *ppuni;

    switch (utf_count) {

    case 1:

	uc_out = (((*p & 0x1f) << 6) |

		  (*(p + 1) & 0x3f));

	break;

    case 2:

	uc_out = (((((*p & 0x0f) << 6) |

		    (*(p + 1) & 0x3f)) << 6) |

		  (*(p + 2) & 0x3f));

	break;

    case 3:

	uc_out = (((((((*p & 0x07) << 6) |

		      (*(p + 1) & 0x3f)) << 6) |

		    (*(p + 2) & 0x3f)) << 6) |

		  (*(p + 3) & 0x3f));

	break;

    case 4:

	uc_out = (((((((((*p & 0x03) << 6) |

			(*(p + 1) & 0x3f)) << 6) |

		      (*(p + 2) & 0x3f)) << 6) |

		    (*(p + 3) & 0x3f)) << 6) |

		  (*(p + 4) & 0x3f));

	break;

    case 5:

	uc_out = (((((((((((*p & 0x01) << 6) |

			  (*(p + 1) & 0x3f)) << 6) |

			(*(p + 2) & 0x3f)) << 6) |

		      (*(p + 3) & 0x3f)) << 6) |

		    (*(p + 4) & 0x3f)) << 6) |

		  (*(p + 5) & 0x3f));

	break;

    }

    *ppuni = p + utf_count;

    return uc_out;

}

/*

 * Combine UTF-8 into Unicode.  Incomplete characters are either ignored, or

 * returned as the UCS replacement character.

 */

dUTF8 HTDecodeUTF8(UTFDecodeState * me, int *c_in_out, UCode_t *result)

{

    dUTF8 rc = dUTF8_ok;

    int c = *c_in_out;

    unsigned uc = UCH(c);

    if (TOASCII(uc) > 127) {

	/*

	 * continue a multibyte character...

	 */

	if (me->utf_count > 0 && (TOASCII(c) & 0xc0) == 0x80) {

	    if (me->utf_count <= 0) {

		me->utf_char = UCS_REPL;

	    } else if (me->utf_count == 1) {

		int limit = (int) (me->utf_buf_p - me->utf_buf) + 1;

		int maybe = 0;

		/*

		 * Check for overlong sequences (from comment in xterm):

		 *   1100000x 10xxxxxx

		 *   11100000 100xxxxx 10xxxxxx

		 *   11110000 1000xxxx 10xxxxxx 10xxxxxx

		 *   11111000 10000xxx 10xxxxxx 10xxxxxx 10xxxxxx

		 *   11111100 100000xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx

		 */

		switch (limit) {

		case 2:

		    maybe = (UCH(me->utf_buf[0]) & 0xfe) == 0xc0;

		    break;

		case 3:

		    maybe = ((UCH(me->utf_buf[0]) == 0xe0) &&

			     (UCH(me->utf_buf[1]) & 0xf0) == 0x80);

		    break;

		case 4:

		    maybe = ((UCH(me->utf_buf[0]) == 0xf0) &&

			     (UCH(me->utf_buf[1]) & 0xf8) == 0x80);

		    break;

		case 5:

		    maybe = ((UCH(me->utf_buf[0]) == 0xf8) &&

			     (UCH(me->utf_buf[1]) & 0xfd) == 0x80);

		    break;

		}

		if (maybe) {

		    while (limit-- > 2) {

			if ((UCH(me->utf_buf[limit]) & 0xc0) != 0x80) {

			    maybe = 0;

			    break;

			}

		    }

		    if (maybe) {

			me->utf_char = UCS_REPL;

		    }

		}

	    }

	    if (me->utf_char == UCS_REPL) {

		rc = dUTF8_err;

	    } else if (me->utf_char || ((uc & 0x7f) >> (7 - me->utf_count))) {

		me->utf_char = (me->utf_char << 6) | (TOASCII(c) & 0x3f);

		if ((me->utf_char >= 0xd800 &&

		     me->utf_char <= 0xdfff) ||

		    (me->utf_char == 0xfffe) ||

		    (me->utf_char == UCS_HIDE)) {

		    me->utf_char = UCS_REPL;

		    rc = dUTF8_err;

		}

	    } else {

		me->utf_char = UCS_REPL;

		rc = dUTF8_err;

	    }

	    me->utf_count--;

	    *(me->utf_buf_p) = (char) c;

	    (me->utf_buf_p)++;

	    if (me->utf_count == 0) {

		*(me->utf_buf_p) = '\0';

		*result = me->utf_char;

		if (*result < 256) {

		    *c_in_out = UCH(*result & 0xff);

		}

		switch (*result) {

		case 0x200e:	/* left-to-right mark */

		case 0x200f:	/* right-to-left mark */

		    /* lynx does not use these */

		    *result = '\0';

		    break;

		}

	    } else {

		rc = dUTF8_more;

	    }

	} else {

	    /*

	     * begin a multibyte character

	     */

	    rc = dUTF8_more;

	    me->utf_buf_p = me->utf_buf;

	    *(me->utf_buf_p) = (char) c;

	    (me->utf_buf_p)++;

	    if ((uc & 0xe0) == 0xc0) {

		me->utf_count = 1;

		me->utf_char = (uc & 0x1f);

	    } else if ((uc & 0xf0) == 0xe0) {

		me->utf_count = 2;

		me->utf_char = (uc & 0x0f);

	    } else if ((uc & 0xf8) == 0xf0) {

		me->utf_count = 3;

		me->utf_char = (uc & 0x07);

	    } else if ((uc & 0xfc) == 0xf8) {

		me->utf_count = 4;

		me->utf_char = (uc & 0x03);

	    } else if ((uc & 0xfe) == 0xfc) {

		me->utf_count = 5;

		me->utf_char = (uc & 0x01);

	    } else {

		me->utf_count = 0;

		me->utf_buf_p = me->utf_buf;

		*(me->utf_buf_p) = '\0';

		rc = dUTF8_err;

	    }

	}

    } else {

	me->utf_count = 0;

	me->utf_buf_p = me->utf_buf;

	*(me->utf_buf_p) = '\0';

    }

#if 0

    if (rc != dUTF8_ok) {

	CTRACE((tfp, "UTF8 %#x ->%#x %s\n",

		uc, UCH(*c_in_out),

		(rc == dUTF8_err) ? "err" : "more"));

    } else {

	if (*result > 127) {

	    CTRACE((tfp, "UTF8 %#x == %#x\n", uc, (int) *result));

	} else if (c != UCS_REPL && !isspace(c)) {

	    CTRACE((tfp, "CHAR %#x == %c (%#x)\n", uc, uc, (int) *result));

	}

    }

#endif

    return rc;

}