snapshot of project "lynx", label v2-7-1ac_0-6

1 files changed, 213 insertions, 0 deletions

diff --git a/src/UCAux.c b/src/UCAux.c
new file mode 100644
index 00000000..cca77ebc
--- /dev/null
+++ b/src/UCAux.c
@@ -0,0 +1,213 @@
+#ifdef EXP_CHARTRANS
+#include "HTUtils.h"
+#include "tcp.h"
+
+#include "HTCJK.h"
+#include "UCDefs.h"
+#include "HTStream.h"
+#include "UCAux.h"
+
+extern HTCJKlang HTCJK;
+extern LYUCcharset LYCharSet_UC[];
+
+PUBLIC BOOL UCCanUniTranslateFrom ARGS1(int, from)
+{
+    if (from < 0)
+	return NO;
+    if (LYCharSet_UC[from].enc == UCT_ENC_7BIT ||
+	LYCharSet_UC[from].enc == UCT_ENC_UTF8)
+	return YES;
+    if (LYCharSet_UC[from].codepoints & (UCT_CP_SUBSETOF_LAT1))
+	return YES;
+    return (LYCharSet_UC[from].UChndl >= 0);
+}
+PUBLIC BOOL UCCanTranslateUniTo ARGS1(int, to)
+{
+    if (to < 0)
+	return NO;
+    return YES;			/* well at least some characters... */
+}
+PUBLIC BOOL UCCanTranslateFromTo ARGS2(int, from, int, to)
+{
+    if (from==to)
+	return YES;
+    if (from < 0 || to < 0)
+	return NO;
+    if (from==0)
+	return UCCanTranslateUniTo(to);
+    if (to==0)
+	return UCCanUniTranslateFrom(from);
+    if (LYCharSet_UC[to].enc == UCT_ENC_UTF8) {
+	return (LYCharSet_UC[from].UChndl >= 0);
+    }
+    {
+	char * fromname = LYCharSet_UC[from].MIMEname;
+	char * toname = LYCharSet_UC[to].MIMEname;
+	if (0==strcmp(fromname,"x-transparent") ||
+	    0==strcmp(toname,"x-transparent")) {
+	    return YES;
+	}
+	if (LYCharSet_UC[from].enc == UCT_ENC_CJK) {
+	    if (HTCJK == NOCJK)	/* use that global flag, for now */
+		return NO;
+	    if (HTCJK == JAPANESE && (
+		0==strcmp(fromname,"euc-jp") ||
+		0==strncmp(fromname,"iso-2022-jp",11) ||
+		0==strcmp(fromname,"shift_jis")
+		))
+		return YES;
+	    return NO;	/* if not handled by (from==to) above */
+	}
+	if (0==strcmp(fromname,"koi8-r")) {
+	    			/* will try to uses stripping of high bit... */
+	    return YES;
+	}
+	    
+	if (0==strcmp(fromname,"koi8-r") || /* from cyrillic */
+	    0==strcmp(fromname,"iso-8859-5") ||
+	    0==strcmp(fromname,"koi-8")) {
+	    if (0!=strcmp(toname,"iso-8859-5") &&
+		0!=strcmp(toname,"koi8-r") &&
+		0!=strcmp(toname,"iso-8859-2"))
+		return NO;
+	}
+    }
+    return (LYCharSet_UC[from].UChndl >= 0);
+}
+
+/* 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 ouptput 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, it's still up to the caller to do something
+** about them.
+*/
+PUBLIC void UCSetTransParams ARGS5(
+    UCTransParams *, 	pT,
+    int,		cs_in,
+    CONST LYUCcharset*,	p_in,
+    int,		cs_out,
+    CONST LYUCcharset*,	p_out
+    )
+{
+    pT->transp = (0==strcmp(p_in->MIMEname,"x-transparent") ||
+		0==strcmp(p_out->MIMEname,"x-transparent"));
+    if (pT->transp) {
+	pT->do_cjk = FALSE;
+	pT->decode_utf8 = FALSE;
+	pT->output_utf8 = FALSE;	/* we may, but won't know about it */
+	pT->do_8bitraw = TRUE;
+	pT->use_raw_char_in = TRUE;
+	pT->strip_raw_char_in = FALSE;
+	pT->pass_160_173_raw = TRUE;
+    } else {
+	BOOL intm_ucs = FALSE;
+	BOOL use_ucs = FALSE;
+	pT->do_cjk = ((p_in->enc == UCT_ENC_CJK) && (HTCJK != NOCJK));
+	pT->decode_utf8 = (p_in->enc == UCT_ENC_UTF8);
+	pT->output_utf8 = (p_out->enc == UCT_ENC_UTF8);
+	if (pT->do_cjk) {
+	    intm_ucs = FALSE;
+	    pT->trans_to_uni = FALSE;
+	    use_ucs = FALSE;
+	    pT->do_8bitraw = FALSE;
+	    pT->pass_160_173_raw = TRUE;
+	    pT->use_raw_char_in = FALSE; /* not used for CJK */
+	    pT->trans_from_uni = FALSE; /* not used for CJK */
+	} else {
+	    intm_ucs = (
+		cs_in == 0 || pT->decode_utf8 ||
+	    (p_in->codepoints & (UCT_CP_SUBSETOF_LAT1|UCT_CP_SUBSETOF_UCS2))
+		);
+	    pT->trans_to_uni = (!intm_ucs &&
+				UCCanUniTranslateFrom(cs_in));
+	    pT->strip_raw_char_in =
+		((!intm_ucs ||
+		  (p_out->enc==UCT_ENC_7BIT) ||
+		  (p_out->repertoire & UCT_REP_SUBSETOF_LAT1)) &&
+		cs_in != cs_out &&
+		0==strcmp(p_in->MIMEname,"koi8-r"));
+	    use_ucs = (intm_ucs || pT->trans_to_uni);
+	    pT->do_8bitraw = (!use_ucs);
+	    pT->pass_160_173_raw = (!use_ucs &&
+				    !(p_in->like8859 & UCT_R_8859SPECL)
+			      );
+	    pT->use_raw_char_in = (!pT->output_utf8 && cs_in == cs_out);
+	    pT->trans_from_uni = (use_ucs && !pT->do_8bitraw &&
+				  !pT->use_raw_char_in &&
+				  UCCanTranslateUniTo(cs_out));
+	}
+    }
+}
+
+PUBLIC void UCTransParams_clear ARGS1(
+    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_from_uni = FALSE;
+}
+
+/* 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)))))
+
+PUBLIC BOOL UCPutUtf8_charstring ARGS3(
+    HTStream *,	target,
+    putc_func_t *,	myPutc,
+    long,	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;
+}
+#endif /* EXP_CHARTRANS */