pT->trans_to_uni = (!intm_ucs &&
pT->trans_to_uni = (BOOL) (!intm_ucs &&
PUBLIC void UCSetTransParams ARGS5(    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, p_in->UChndl, p_out->MIMEname, p_out->UChndl); */	   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 = (!strcmp(p_in->MIMEname, "x-transparent") ||		  !strcmp(p_out->MIMEname, "x-transparent"));    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 = (p_out->enc == UCT_ENC_8BIT_C0);	pT->trans_C0_to_uni = (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 = ((p_in->enc == UCT_ENC_CJK) && (HTCJK != NOCJK));	/*	**  Set these elements based on whether	**  we are dealing with UTF-8. - FM	*/	pT->decode_utf8 = (p_in->enc == UCT_ENC_UTF8);	pT->output_utf8 = (p_out->enc == UCT_ENC_UTF8);	if (pT->do_cjk) {	    /*	    **  Set up the structure for a CJK input with	    **  a CJK output (HTCJK != NOCJK). - FM	    */	    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. - 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 = (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 = (!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 = (pT->trans_to_uni &&				   p_in->enc == UCT_ENC_8BIT_C0);	    /*	    **  We set this, presently, for VISCII. - FM	    */	    pT->repl_translated_C0 = (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 = (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 = (!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 = (!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 = (!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 = (use_ucs && !pT->do_8bitraw &&				  !pT->use_raw_char_in &&				  UCCanTranslateUniTo(cs_out));	}    }}