// ============================================================================
// Internet Character Set Conversion: Input from ISO-2022-JP
// ============================================================================

#include "private.h"
#include "fechrcnv.h"
#include "jisobj.h"

#include "codepage.h"

/******************************************************************************
**************************   C O N S T R U C T O R   **************************
******************************************************************************/

CInccJisIn::CInccJisIn(UINT uCodePage, int nCodeSet) : CINetCodeConverter(uCodePage, nCodeSet)
{
    Reset();    // initialization
    return ;
}

/******************************************************************************
*******************************   R E S E T   *********************************
******************************************************************************/

void CInccJisIn::Reset()
{
	m_pfnConv = ConvMain;   
	m_pfnCleanUp = CleanUpMain;
	m_fShift = FALSE;
	m_fJapan = FALSE;
	m_fLeadByte = FALSE ; 
	m_tcLeadByte = 0 ;
	m_nESCBytes = 0 ;
	m_eEscState = JIS_ASCII ; 
    return ;
}

/******************************************************************************
*************************   C O N V E R T   C H A R   *************************
******************************************************************************/

HRESULT CInccJisIn::ConvertChar(UCHAR tc, int cchSrc)
{
	BOOL fDone = (this->*m_pfnConv)(tc);
    if (fDone)
        return S_OK;
    else
        return E_FAIL;
}

/******************************************************************************
*****************************   C L E A N   U P   *****************************
******************************************************************************/

BOOL CInccJisIn::CleanUp()
{
	return (this->*m_pfnCleanUp)();
}

/******************************************************************************
****************************   C O N V   M A I N   ****************************
******************************************************************************/

BOOL CInccJisIn::ConvMain(UCHAR tc)
{
	BOOL fDone = TRUE;

	switch (tc) {
	case SO:
		m_fShift = TRUE;
		break;

	case SI:
		m_fShift = FALSE;
		m_fLeadByte = FALSE;
		break;

	default:
		if (m_fShift) {
			fDone = Output(tc | 0x80);
			// it may continue to convert to Unicode, so we need to know
			// whether current byte is a lead byte or not
			m_fLeadByte = ~m_fLeadByte ;
		} else {
			if (tc == ESC) {
				m_pfnConv = ConvEsc;
				m_pfnCleanUp = CleanUpEsc;
				m_nESCBytes++;
			} else {
				if (m_fJapan) {
					if (tc == '*') {
						m_pfnConv = ConvStar;
						m_pfnCleanUp = CleanUpStar;
					} else {
						m_pfnConv = ConvDoubleByte;
						m_pfnCleanUp = CleanUpDoubleByte;
						m_tcLeadByte = tc;
					}
				} else {
                    switch ( m_eEscState )
                    {
                        case JIS_ASCII:
                            fDone = Output(tc);
                            break ;
                        case JIS_Roman:
#if 0
                            if ( tc == 0x7e ) /* tilde in ACSII -> overline */
                            {
                                Output(0x81);
                                fDone = Output(0x50);
                            }
                            else
                                fDone = Output(tc);
#else
                            fDone = Output(tc);
#endif
                            break ;
                        case JIS_Kana:
                            fDone = Output(tc | 0x80 );
                            break ;
                        default:
                            fDone = Output(tc);
                            break ;
                    }
				}
			}
		}
		break;
	}
	return fDone;
}

/******************************************************************************
************************   C L E A N   U P   M A I N   ************************
******************************************************************************/

BOOL CInccJisIn::CleanUpMain()
{
	return TRUE;
}

/******************************************************************************
*****************************   C O N V   E S C   *****************************
******************************************************************************/

BOOL CInccJisIn::ConvEsc(UCHAR tc)
{
	switch (tc) {
	case ISO2022_IN_CHAR:
		m_pfnConv = ConvIsoIn;
		m_pfnCleanUp = CleanUpIsoIn;
		m_nESCBytes++;
		return TRUE;

	case ISO2022_OUT_CHAR:
		m_pfnConv = ConvIsoOut;
		m_pfnCleanUp = CleanUpIsoOut;
		m_nESCBytes++;
		return TRUE;

	default:
		m_pfnConv = ConvMain;
		m_pfnCleanUp = CleanUpMain;
		m_nESCBytes = 0 ;
		(void)Output(ESC);
		if (SUCCEEDED(ConvertChar(tc)))
            return TRUE;
        else
            return FALSE;
	}
}

/******************************************************************************
*************************   C L E A N   U P   E S C   *************************
******************************************************************************/

BOOL CInccJisIn::CleanUpEsc()
{
	m_pfnConv = ConvMain;
	m_pfnCleanUp = CleanUpMain;
	return Output(ESC);
}

/******************************************************************************
**************************   C O N V   I S O   I N   **************************
******************************************************************************/

BOOL CInccJisIn::ConvIsoIn(UCHAR tc)
{
	switch (tc) {
	case ISO2022_IN_JP_CHAR1:       /* 'B' */
	case ISO2022_IN_JP_CHAR2:       /* '@' */
		m_pfnConv = ConvMain;
		m_pfnCleanUp = CleanUpMain;
		m_fJapan = TRUE;
		m_nESCBytes = 0 ;
		return TRUE;

	case ISO2022_IN_JP_CHAR3_1:     /* '(' */
		m_pfnConv = ConvIsoInJp;
		m_pfnCleanUp = CleanUpIsoInJp;
		m_nESCBytes++ ;
		return TRUE;

	default:
		m_pfnConv = ConvMain;
		m_pfnCleanUp = CleanUpMain;
		m_nESCBytes = 0 ;
		(void)Output(ESC);
		(void)ConvertChar(ISO2022_IN_CHAR);
        if (SUCCEEDED(ConvertChar(tc)))
            return TRUE;
        else
            return FALSE;
	}
}

/******************************************************************************
**********************   C L E A N   U P   I S O   I N   **********************
******************************************************************************/

BOOL CInccJisIn::CleanUpIsoIn()
{
	m_pfnConv = ConvMain;
	m_pfnCleanUp = CleanUpMain;

	(void)Output(ESC);
	(void)ConvertChar(ISO2022_IN_CHAR);
	return CleanUp();
}

/******************************************************************************
***********************   C O N V   I S O   I N   J P   ***********************
******************************************************************************/

BOOL CInccJisIn::ConvIsoInJp(UCHAR tc)
{
	m_pfnConv = ConvMain;
	m_pfnCleanUp = CleanUpMain;
	m_nESCBytes = 0 ;

	if (tc == ISO2022_IN_JP_CHAR3_2) {
		m_fJapan = TRUE;
		return TRUE;
	} else {
		(void)Output(ESC);
		(void)ConvertChar(ISO2022_IN_CHAR);
		(void)ConvertChar(ISO2022_IN_JP_CHAR3_1);
        if (SUCCEEDED(ConvertChar(tc)))
            return TRUE;
        else
            return FALSE;
	}
}

/******************************************************************************
*******************   C L E A N   U P   I S O   I N   J P   *******************
******************************************************************************/

BOOL CInccJisIn::CleanUpIsoInJp()
{
	m_pfnConv = ConvMain;
	m_pfnCleanUp = CleanUpMain;
	m_nESCBytes = 0 ;

	(void)Output(ESC);
	(void)ConvertChar(ISO2022_IN_CHAR);
	(void)ConvertChar(ISO2022_IN_JP_CHAR3_1);
	return CleanUp();
}

/******************************************************************************
*************************   C O N V   I S O   O U T   *************************
******************************************************************************/

BOOL CInccJisIn::ConvIsoOut(UCHAR tc)
{
	m_pfnConv = ConvMain;
	m_pfnCleanUp = CleanUpMain;
	m_nESCBytes = 0 ;

	switch (tc) {
	case ISO2022_OUT_JP_CHAR1:  /* B */
		m_fJapan = FALSE;
		m_eEscState = JIS_ASCII ;
		return TRUE;

	case ISO2022_OUT_JP_CHAR2:  /* J */
	case ISO2022_OUT_JP_CHAR4:  /* H */
		m_fJapan = FALSE;
		m_eEscState = JIS_Roman ;
		return TRUE;       

	case ISO2022_OUT_JP_CHAR3: /* I */
		m_fJapan = FALSE;
		m_eEscState = JIS_Kana ; 
		return TRUE;       

	default:
		(void)Output(ESC);
		(void)ConvertChar(ISO2022_OUT_CHAR);
        if (SUCCEEDED(ConvertChar(tc)))
            return TRUE;
        else
            return FALSE;
	}
}

/******************************************************************************
*********************   C L E A N   U P   I S O   O U T   *********************
******************************************************************************/

BOOL CInccJisIn::CleanUpIsoOut()
{
	m_pfnConv = ConvMain;
	m_pfnCleanUp = CleanUpMain;
	m_nESCBytes = 0 ;

	(void)Output(ESC);
	(void)ConvertChar(ISO2022_OUT_CHAR);
	return CleanUp();
}

/******************************************************************************
****************************   C O N V   S T A R   ****************************
******************************************************************************/

BOOL CInccJisIn::ConvStar(UCHAR tc)
{
	m_pfnConv = ConvMain;
	m_pfnCleanUp = CleanUpMain;

	return Output(tc | 0x80);
}

/******************************************************************************
************************   C L E A N   U P   S T A R   ************************
******************************************************************************/

BOOL CInccJisIn::CleanUpStar()
{
	m_pfnConv = ConvMain;
	m_pfnCleanUp = CleanUpMain;

	return Output('*');
}

/******************************************************************************
*********************   C O N V   D O U B L E   B Y T E   *********************
******************************************************************************/

BOOL CInccJisIn::ConvDoubleByte(UCHAR tc)
{
	BOOL bRet ;
	UCHAR tcSJisLB;
	UCHAR tcSJisTB;

	m_pfnConv = ConvMain;
	m_pfnCleanUp = CleanUpMain;

	tcSJisLB = ((m_tcLeadByte - 0x21) >> 1) + 0x81;
	if (tcSJisLB > 0x9f)
		tcSJisLB += 0x40;

	tcSJisTB = tc + (m_tcLeadByte & 1 ? 0x1f : 0x7d);
	if (tcSJisTB >= 0x7f)
		tcSJisTB++;

	(void)Output(tcSJisLB);
	bRet = Output(tcSJisTB);

	m_tcLeadByte = 0 ;
	return bRet ;
}

/******************************************************************************
*****************   C L E A N   U P   D O U B L E   B Y T E   *****************
******************************************************************************/

BOOL CInccJisIn::CleanUpDoubleByte()
{
	BOOL bRet ;
	m_pfnConv = ConvMain;
	m_pfnCleanUp = CleanUpMain;

	bRet = Output(m_tcLeadByte);
	m_tcLeadByte = 0 ;
	return bRet ;
}

int CInccJisIn::GetUnconvertBytes()
{
    if ( m_tcLeadByte || m_fLeadByte )
        return 1 ;
    else if ( m_nESCBytes )
        return m_nESCBytes < 4 ? m_nESCBytes : 3 ;
    else
        return 0 ;
}

DWORD CInccJisIn::GetConvertMode()
{
    // 0xC42C -> 50220 ISO-2022-JP
    return ( m_fJapan ? 1 : 0 ) + ( m_fShift ? 2 : 0 ) | 0xC42C0000 ;
}

void CInccJisIn::SetConvertMode(DWORD mode)
{
    Reset();
    if ( mode & 0x00000001 )
        m_fJapan = TRUE ;
    if ( mode & 0x00000002 ) 
        m_fShift = TRUE ;

 	return ;
}

// ============================================================================
// Internet Character Set Conversion: Output to ISO-2022-JP
// ============================================================================

#define VOICE_MARK_OFFSET       0xA0
#define VOICE_MARK_DEDF_OFFSET  0xC8

#if 0   // Shift JIS Table - not used
// this is the table used to determine whether the kana char is voiced sound markable
// if it is, what is the combined full width kana.
static WCHAR g_wVoiceMarkKana[48] =
{
  /*               0,      1,      2,      3,      4,      5,      6,      7,      8,      9,      A,      B,      C,      D,      E,      F, */

  /* a0-af */    0x0,    0x0,    0x0,    0x0,    0x0,    0x0,    0x0,    0x0,    0x0, 0x8394,    0x0,    0x0,    0x0,    0x0,    0x0,    0x0,
  /* b0-bf */    0x0,    0x0,    0x0,    0x0,    0x0,    0x0, 0x834B, 0x834D, 0x834f, 0x8351, 0x8353, 0x8355, 0x8357, 0x8359, 0x835B, 0x835D,
  /* c0-cf */ 0x835F, 0x8361, 0x8364, 0x8366, 0x8368,    0x0,    0x0,    0x0,    0x0,    0x0, 0x836F, 0x8372, 0x8375, 0x8378, 0x837B,    0x0,

};

// special voiced sound mark '0xde' conversion
static WCHAR g_wMarkDEKana[16] =
{
  /* c8-cf */  0x0, 0x0, 0x836F, 0x8372, 0x8375, 0x8378, 0x837B, 0x0,
};


// special voiced sound mark '0xdf' conversion
static WCHAR g_wMarkDFKana[16] =
{
  /* c8-cf */ 0x0, 0x0, 0x8370, 0x8373, 0x8376, 0x8379, 0x837C, 0x0,
};

// this is the table used to convert half width kana to full width kana
static WCHAR g_wFullWKana[64] =
{
  /*               0,      1,      2,      3,      4,      5,      6,      7,      8,      9,      A,      B,      C,      D,      E,      F, */

  /* a0-af */    0x0, 0x8142, 0x8175, 0x8176, 0x8141, 0x8145, 0x8392, 0x8340, 0x8342, 0x8344, 0x8346, 0x8348, 0x8383, 0x8385, 0x8387, 0x8362,
  /* b0-bf */ 0x815B, 0x8341, 0x8343, 0x8345, 0x8347, 0x8349, 0x834A, 0x834C, 0x834E, 0x8350, 0x8352, 0x8354, 0x8356, 0x8358, 0x835A, 0x835C,
  /* c0-cf */ 0x835E, 0x8360, 0x8363, 0x8365, 0x8367, 0x8369, 0x836A, 0x836B, 0x836C, 0x836D, 0x836E, 0x8371, 0x8374, 0x8377, 0x837A, 0x837D,
  /* d0-df */ 0x837E, 0x8380, 0x8381, 0x8382, 0x8384, 0x8386, 0x8388, 0x8389, 0x838A, 0x838B, 0x838C, 0x838D, 0x838F, 0x8393, 0x814A, 0x814B,
};
#endif

// JIS Table

// this is the table used to determine whether the kana char is voiced sound markable
// if it is, what is the combined full width kana.
static WCHAR g_wVoiceMarkKana[48] =
{
  /*               0,      1,      2,      3,      4,      5,      6,      7,      8,      9,      A,      B,      C,      D,      E,      F, */

  /* a0-af */    0x0,    0x0,    0x0,    0x0,    0x0,    0x0,    0x0,    0x0,    0x0, 0x2574,    0x0,    0x0,    0x0,    0x0,    0x0,    0x0,
  /* b0-bf */    0x0,    0x0,    0x0,    0x0,    0x0,    0x0, 0x252c, 0x252e, 0x2530, 0x2532, 0x2534, 0x2536, 0x2538, 0x253A, 0x253C, 0x253E,
  /* c0-cf */ 0x2540, 0x2542, 0x2545, 0x2547, 0x2549,    0x0,    0x0,    0x0,    0x0,    0x0, 0x2550, 0x2553, 0x2556, 0x2559, 0x255C,    0x0,

};

// special voiced sound mark '0xde' conversion
static WCHAR g_wMarkDEKana[16] =
{
  /* c8-cf */  0x0, 0x0, 0x2550, 0x2553, 0x2556, 0x2559, 0x255C, 0x0,
};

// special voiced sound mark '0xdf' conversion
static WCHAR g_wMarkDFKana[16] =
{
  /* c8-cf */ 0x0, 0x0, 0x2551, 0x2554, 0x2557, 0x255A, 0x255D, 0x0,
};

// this is the table used to convert half width kana to full width kana
static WCHAR g_wFullWKana[64] =
{
  /*               0,      1,      2,      3,      4,      5,      6,      7,      8,      9,      A,      B,      C,      D,      E,      F, */

  /* a0-af */    0x0, 0x2123, 0x2156, 0x2157, 0x2122, 0x2126, 0x2572, 0x2521, 0x2523, 0x2525, 0x2527, 0x2529, 0x2563, 0x2565, 0x2567, 0x2543,
  /* b0-bf */ 0x213C, 0x2522, 0x2524, 0x2526, 0x2528, 0x252A, 0x252B, 0x252D, 0x252f, 0x2531, 0x2533, 0x2535, 0x2537, 0x2539, 0x253B, 0x253D,
  /* c0-cf */ 0x253F, 0x2541, 0x2544, 0x2546, 0x2548, 0x254A, 0x254B, 0x254C, 0x254D, 0x254E, 0x254F, 0x2552, 0x2555, 0x2558, 0x255B, 0x255E,
  /* d0-df */ 0x255F, 0x2560, 0x2561, 0x2562, 0x2564, 0x2566, 0x2568, 0x2569, 0x256A, 0x256B, 0x256C, 0x256D, 0x256F, 0x2573, 0x212B, 0x212C,
};

/******************************************************************************
**************************   C O N S T R U C T O R   **************************
******************************************************************************/

CInccJisOut::CInccJisOut(UINT uCodePage, int nCodeSet, DWORD dwFlag, WCHAR *lpFallBack) : CINetCodeConverter(uCodePage, nCodeSet)
{
    m_dwFlag = dwFlag;
    // Per Office team's request, we should disable BESTFITCHARS feature for now.
    m_dwFlag &= ~MLCONVCHARF_NOBESTFITCHARS;
    m_lpFallBack = lpFallBack;
    Reset();    // initialization
    return ;
}

/******************************************************************************
*******************************   R E S E T   *********************************
******************************************************************************/

void CInccJisOut::Reset()
{
	m_fDoubleByte = FALSE;
	m_fKana = FALSE;
	m_fJapan = FALSE;
	m_fSaveByte = FALSE;
	m_tcLeadByte = 0 ;
	m_tcPrevByte = 0 ;
	m_eKanaMode = SIO_MODE ; 
    return ;
}

/******************************************************************************
*************************   C O N V E R T   C H A R   *************************
******************************************************************************/

HRESULT CInccJisOut::ConvertChar(UCHAR tc, int cchSrc)
{
	BOOL fDone = TRUE;
    HRESULT hr = S_OK;

	if (!m_fDoubleByte) {
		if ((tc >= 0x81 && tc <= 0x9f) || (tc >= 0xe0 && tc <= 0xfc )) { 
			// Switch to Double Byte Code
			if (m_fKana) {
			    if ( SIO_MODE == m_eKanaMode )
    				fDone = Output(SI);
			    else if ( (FULL_MODE == m_eKanaMode) && !(m_dwFlag & MLCONVCHARF_NOBESTFITCHARS))
			    {
				    fDone = KanaCleanUp();
				    m_fJapan = TRUE; // in FULL mode, Kana are bouble byte code too.
			    }
			    m_fKana = FALSE;
			}
			if (!m_fJapan) {
				(void)Output(ESC);  // ESC $ B - JIS-83
				(void)Output(ISO2022_IN_CHAR);
				fDone = Output(ISO2022_IN_JP_CHAR1);
				m_fJapan = TRUE;
			}
			m_fDoubleByte = TRUE;
			m_tcLeadByte = tc;
		} else if (tc >= 0xa1 && tc <= 0xdf) { 
			// Single Byte Katakana Code
			if (m_fJapan) {
			    if ( (FULL_MODE == m_eKanaMode) && !(m_dwFlag & MLCONVCHARF_NOBESTFITCHARS))
				    m_fKana = TRUE; // no mode changing
			    else if ( (SIO_MODE == m_eKanaMode) || (FULL_MODE == m_eKanaMode))
			    {
    				(void)Output(ESC);  // ESC ( B - ACSII
	    			(void)Output(ISO2022_OUT_CHAR);
		    		fDone = Output(ISO2022_OUT_JP_CHAR1);
			    }
				m_fJapan = FALSE;
			}
			if (!m_fKana) {
			    switch ( m_eKanaMode )
			    {
			        case SIO_MODE :
        				fDone = Output(SO);
        				break ;
			        case ESC_MODE :
		        		(void)Output(ESC);  // ESC ( I - Kana mode
		        		(void)Output(ISO2022_OUT_CHAR);
        				fDone = Output(ISO2022_OUT_JP_CHAR3);
        				break ;
			        case FULL_MODE :
						// Don't switch if NO_BEST_FIT_CHAR
						if (!(m_dwFlag & MLCONVCHARF_NOBESTFITCHARS))
						{
        					(void)Output(ESC);  // ESC $ B - JIS 83
		        			(void)Output(ISO2022_IN_CHAR);
		        			fDone = Output(ISO2022_IN_JP_CHAR1);        				
						}
						break;

			    }
			    m_fKana = TRUE;
			}
			if ( FULL_MODE ==  m_eKanaMode )
			{
			    hr = ConvFullWidthKana(tc);
				if (SUCCEEDED(hr))
					fDone = TRUE;
				else
					fDone = FALSE;
			}
			else
			    fDone = Output(tc & 0x7f);
		} else {
			// Single Byte Code
			if (m_fKana) {
			    if ( SIO_MODE == m_eKanaMode )
    				fDone = Output(SI);
			    else {
    				if ( FULL_MODE == m_eKanaMode )
    				    fDone = KanaCleanUp();
    				(void)Output(ESC);  // ESC ( B - ACSII
	    			(void)Output(ISO2022_OUT_CHAR);
		    		fDone = Output(ISO2022_OUT_JP_CHAR1);
			    }
			    m_fKana = FALSE;
			}
			if (m_fJapan) {
				(void)Output(ESC);  // ESC ( B - ACSII
				(void)Output(ISO2022_OUT_CHAR);
				fDone = Output(ISO2022_OUT_JP_CHAR1);
				m_fJapan = FALSE;
			}
			fDone = Output(tc);
		}
	} else {

        // map extended char (0xfa40-0xfc4b) to a special range
        if (m_tcLeadByte >= 0xfa && m_tcLeadByte <= 0xfc && tc >= 0x40 )
        {
            WCHAR  wcDBCS ;

            wcDBCS = ((WCHAR) m_tcLeadByte ) << 8 | tc ;

            if ( wcDBCS >= 0xfa40 && wcDBCS <= 0xfa5b )
            {
                if ( wcDBCS <= 0xfa49 )
                    wcDBCS = wcDBCS - 0x0b51 ;
                else if ( wcDBCS >= 0xfa4a && wcDBCS <= 0xfa53 )
                    wcDBCS = wcDBCS - 0x072f6 ;
                else if ( wcDBCS >= 0xfa54 && wcDBCS <= 0xfa57 )
                    wcDBCS = wcDBCS - 0x0b5b ;
                else if ( wcDBCS == 0xfa58 )
                    wcDBCS = 0x878a ;
                else if ( wcDBCS == 0xfa59 )
                    wcDBCS = 0x8782 ;
                else if ( wcDBCS == 0xfa5a )
                    wcDBCS = 0x8784 ;
                else if ( wcDBCS == 0xfa5b )
                    wcDBCS = 0x879a ;
            }
            else if ( wcDBCS >= 0xfa5c && wcDBCS <= 0xfc4b )
            {
                if ( tc < 0x5c )
                    wcDBCS = wcDBCS - 0x0d5f;
                else if ( tc >= 0x80 && tc <= 0x9B )
                    wcDBCS = wcDBCS - 0x0d1d;
                else
                    wcDBCS = wcDBCS - 0x0d1c;
            }
            tc = (UCHAR) wcDBCS ;
            m_tcLeadByte = (UCHAR) ( wcDBCS >> 8 ) ;
        }

		// Convert Double Byte Code
		m_tcLeadByte -= ((m_tcLeadByte > 0x9f) ? 0xb1 : 0x71);
		m_tcLeadByte = m_tcLeadByte * 2 + 1;
		if (tc > 0x9e) {
			tc -= 0x7e;
			m_tcLeadByte++;
		} else {
			if (tc > 0x7e)
				tc--;
			tc -= 0x1f;
		}
		(void)Output(m_tcLeadByte);
		fDone = Output(tc);
		m_fDoubleByte = FALSE;
		m_tcLeadByte = 0 ;
	}

    if (fDone)
        return hr;
    else
        return E_FAIL;
}

/******************************************************************************
*****************************   C L E A N   U P   *****************************
******************************************************************************/

BOOL CInccJisOut::CleanUp()
{
	BOOL fDone = TRUE;

	// Discard m_byLeadByte: if (m_fDoubleByte) Output(m_byLeadByte);

	fDone = KanaCleanUp();

	if (m_fKana)
	{
		if ( SIO_MODE == m_eKanaMode )
		    fDone = Output(SI);
		else if (!(m_dwFlag & MLCONVCHARF_NOBESTFITCHARS))   // FULL mode and ESC mode
		{
		    (void)Output(ESC); // ESC ( B - ASCII
		    (void)Output(ISO2022_OUT_CHAR);
		    fDone = Output(ISO2022_OUT_JP_CHAR1);
		}
		m_fKana = FALSE ;
	}

	if (m_fJapan) {
		(void)Output(ESC); // ESC ( B - ASCII
		(void)Output(ISO2022_OUT_CHAR);
		fDone = Output(ISO2022_OUT_JP_CHAR1);
		m_fJapan = FALSE ;
	}

	return fDone;
}


/******************************************************************************
*************************   C O N V E R T   C H A R   *************************
******************************************************************************/

HRESULT CInccJisOut::ConvFullWidthKana(UCHAR tc)
{
    BOOL fDone = TRUE ;
    int index ;
    WCHAR DoubleBytes ;
    HRESULT hr = S_OK;

    if (m_dwFlag & MLCONVCHARF_NOBESTFITCHARS)
    {
        UCHAR szDefaultChar[3] = {0x3f}; // possible DBCS + null

        if (m_lpFallBack && (m_dwFlag & MLCONVCHARF_USEDEFCHAR))
        {
            // only take SBCS, no DBCS character
            if ( 1 != WideCharToMultiByte(CP_JPN_SJ, 0,
                         (LPCWSTR)m_lpFallBack, 1,
                         (LPSTR)szDefaultChar, ARRAYSIZE(szDefaultChar), NULL, NULL ))
                szDefaultChar[0] = 0x3f;
        }

        if (m_dwFlag & (MLCONVCHARF_NCR_ENTITIZE|MLCONVCHARF_NAME_ENTITIZE))
        {
            char    szChar[2] = {0};
            char    szDstStr[10] = {0};
            WCHAR   szwChar[2];
            int     cCount;

            szChar[0] = tc;
                
            if (MultiByteToWideChar(CP_JPN_SJ, 0, szChar, -1, szwChar, ARRAYSIZE(szwChar)))
            {
                // Output NCR entity
                Output('&');
                Output('#');
                _ultoa((unsigned long)szwChar[0], (char*)szDstStr, 10);
                cCount = lstrlenA(szDstStr);
                for (int i=0; i< cCount; i++)
                {
                    Output(szDstStr[i]);
                }
                fDone = Output(';');
            }
            else
            {
				fDone = Output(szDefaultChar[0]); // use default char
                hr = S_FALSE;
            }
        }
        else
        {
 		    fDone = Output(szDefaultChar[0]); // use default char
            hr = S_FALSE;
        }
    }
    else
	{
		// voiced sound mark or semi-voiced sound mark 
		if ( m_fSaveByte && ( tc == 0xde || tc == 0xdf ) )
		{
			if ( m_tcPrevByte >= 0x0CA && m_tcPrevByte <= 0x0CE ) 
			{
				index = m_tcPrevByte - VOICE_MARK_DEDF_OFFSET ;
				if ( tc == 0xde )
					DoubleBytes = g_wMarkDEKana[index] ;
				else
					DoubleBytes = g_wMarkDFKana[index] ;
			}
			else
			{
				index = m_tcPrevByte - VOICE_MARK_OFFSET ;
				DoubleBytes = g_wVoiceMarkKana[index] ;
			}
			Output( (UCHAR) (DoubleBytes >> 8 ));
			fDone = Output( (UCHAR) DoubleBytes );
			m_fSaveByte = FALSE ;
			m_tcPrevByte = '\0' ;
		}
		else 
		{

			// output previous saved voice sound markable char
			if ( m_fSaveByte )
			{
				index = m_tcPrevByte - VOICE_MARK_OFFSET ;
				DoubleBytes = g_wFullWKana[index] ;
				Output( (UCHAR) (DoubleBytes >> 8 ) );
				fDone = Output( (UCHAR) DoubleBytes );
				m_fSaveByte = FALSE ;
				m_tcPrevByte = '\0' ;
			}

			// half width kana
			if ( tc >= 0xa1 && tc <= 0xdf )
			{
				index = tc - VOICE_MARK_OFFSET ;
				// check if this char can be combined with voice sound mark
				if ( g_wVoiceMarkKana[index] )
				{
					m_fSaveByte = TRUE ;
					m_tcPrevByte = tc ;
				}
				// convert half width kana to full width kana
				else
				{
					DoubleBytes = g_wFullWKana[index] ;
					Output( (UCHAR) ( DoubleBytes >> 8 ));
					fDone = Output( (UCHAR) DoubleBytes );
				}
			}
			else
				fDone = Output(tc);
		}
    }

    if (fDone)
        return hr;
    else
        return E_FAIL;

}

/******************************************************************************
*************************** K A N A  C L E A N   U P   ************************
******************************************************************************/

BOOL CInccJisOut::KanaCleanUp()
{
    BOOL fDone = TRUE;
    WCHAR DoubleBytes ;
    int index ;

    // output previous saved voice sound markable char
    if ( m_fSaveByte )
    {
        index = m_tcPrevByte - VOICE_MARK_OFFSET ;
        DoubleBytes = g_wFullWKana[index] ;
        Output( (UCHAR) ( DoubleBytes >> 8 ));
        fDone = Output( (UCHAR) DoubleBytes );
        m_fSaveByte = FALSE ;
        m_tcPrevByte = '\0' ;
    }

	return fDone;
}

int CInccJisOut::GetUnconvertBytes()
{
    if ( m_tcLeadByte )
        return 1 ;
    else
        return 0 ;
}

DWORD CInccJisOut::GetConvertMode()
{
    return ( m_fJapan ? 1 : 0 ) +  ( m_fKana ? 2 : 0 ) ;
}

void CInccJisOut::SetConvertMode(DWORD mode)
{
    Reset();
    if ( mode & 0x00000001 ) 
        m_fJapan = TRUE ;
    if ( mode & 0x00000002 ) 
        m_fKana = TRUE ;
    return ;
}

void CInccJisOut::SetKanaMode(UINT uCodePage)
{
    switch ( uCodePage )
    {
        case    CP_ISO_2022_JP_ESC:
            m_eKanaMode = ESC_MODE ; 
            break ;
        case    CP_ISO_2022_JP_SIO:
            m_eKanaMode = SIO_MODE ; 
            break ;
        default :
            m_eKanaMode = FULL_MODE ; 
            break ;
    }
    return ;
}