TnbJisStr.h

[詳解]

#pragma once
#include "TnbStr.h"
 
 
 
//T-TestCaseコードカバレッジDisable
#pragma comment(user,"T-Coverage Disable")
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CJisStr : public IComparableT<TNB::CJisStr>
{
    CAscii  m_vtcText;          
    enum { ESC = 0x1B };
    static bool IsKanji(int c)
    {
        return ((c >= 0x81 && c <= 0x9F) || (c >= 0xE0 && c <= 0xFC));
    }
    static bool IsHankaku(int c)
    {
        return (c >= 0xa0 && c <= 0xdf);
    }
    /*
     * [変換] 半角カナを全角カナに変換.
     *  @param[out] _zenkaku 変換後の全角を格納
     *  @param[in] P 半角カナのポインタ。次の文字も確認します。
     *  @retval 1 濁点、半濁点無し変換
     *  @retval 2 濁点、半濁点あり変換
     */
    static int ms_HanToZen(WORD& _zenkaku, const BYTE* P)
    {
        const static WORD z[64] =
        {
            0x2121, 0x2123, 0x2156, 0x2157, 0x2122, 0x2126, 0x2572, 0x2521,
            0x2523, 0x2525, 0x2527, 0x2529, 0x2563, 0x2565, 0x2567, 0x2543,
            0x213c, 0x2522, 0x2524, 0x2526, 0x2528, 0x252a, 0x252b, 0x252d,
            0x252f, 0x2531, 0x2533, 0x2535, 0x2537, 0x2539, 0x253b, 0x253d,
            0x253f, 0x2541, 0x2544, 0x2546, 0x2548, 0x254a, 0x254b, 0x254c,
            0x254d, 0x254e, 0x254f, 0x2552, 0x2555, 0x2558, 0x255b, 0x255e,
            0x255f, 0x2560, 0x2561, 0x2562, 0x2564, 0x2566, 0x2568, 0x2569,
            0x256a, 0x256b, 0x256c, 0x256d, 0x256f, 0x2573, 0x212b, 0x212c
        };
        struct TMark
        {
            BYTE han;
            WCHAR zen;
        };
        const static TMark marks1[] =
        {
            {0xb3, 0x2574}, {0xb6, 0x252c}, {0xb7, 0x252e}, {0xb8, 0x2530},
            {0xb9, 0x2532}, {0xba, 0x2534}, {0xbb, 0x2536}, {0xbc, 0x2538},
            {0xbd, 0x253a}, {0xbe, 0x253c}, {0xbf, 0x253e}, {0xc0, 0x2540},
            {0xc1, 0x2542}, {0xc2, 0x2545}, {0xc3, 0x2547}, {0xc4, 0x2549},
            {0xca, 0x2550}, {0xcb, 0x2553}, {0xcc, 0x2556}, {0xcd, 0x2559},
            {0xce, 0x255c}, {0, 0}
        };
        const static TMark marks2[] = 
        {
            {0xca, 0x2551}, {0xcb, 0x2554}, {0xcc, 0x2557}, {0xcd, 0x255a},
            {0xce, 0x255d}, {0, 0}
        };
        if ( P[1] == 0xde/*濁音符*/ )
        {
            loop ( i, countof(marks1) )
            {
                if ( P[0] == marks1[i].han )
                {
                    _zenkaku = marks1[i].zen;
                    return 2;
                }
            }
        }
        else if ( P[1] == 0xdf/*半濁音符*/ )
        {
            loop ( i, countof(marks2) )
            {
                if ( P[0] == marks2[i].han )
                {
                    _zenkaku = marks2[i].zen;
                    return 2;
                }
            }
        }
        int r = P[0] - 0xa0;
        ASSERT( r >= 0 && r < countof(z) );
        _zenkaku = z[r];
        return 1;
    }
    /*
     * [変換] SJISの2バイトをJISに変換
     *  @param[in,out] ph 上位BYTE
     *  @param[in,out] pl 下位BYTE
     */
    static void ms_SjisToJis(UINT *ph, UINT *pl)
    {
        *ph = *ph & 0xff;
        *pl = *pl & 0xff;
        if ( *ph <= 0x9F ) 
        {
            if ( *pl < 0x9F )
            {
                *ph = (*ph << 1) - 0xE1;
            }
            else 
            {
                *ph = (*ph << 1) - 0xE0;
            }
        }
        else
        {
            if ( *pl < 0x9F )
            {
                *ph = (*ph << 1) - 0x161;
            }
            else
            {
                *ph = (*ph << 1) - 0x160;
            }
        }
        if ( *pl < 0x7F )
        {
            *pl -= 0x1F;
        } 
        else if ( *pl < 0x9F )
        {
            *pl -= 0x20;
        }
        else 
        {
            *pl -= 0x7E;
        }
    }
    /*
     * [変換] SJIS→ISO2022JP.
     *      sjis_iso2022jp - SJISをISO-2022-JP(JIS)に変換 (RFC 1468)
     *  @param[in] pSjis 元のSJIS文字列。
     *  @param[out] pIso2022 変換したISO2022JP文字列。バッファは元の文字列の4倍必要。
     *  @return 変換後の文字数。
     */
    static INT_PTR ms_SjisToIso2022jp(LPCSTR pSjis, LPSTR pIso2022)
    {
        const BYTE* p = reinterpret_cast<const BYTE*>(pSjis);
        BYTE* r = reinterpret_cast<BYTE*>(pIso2022);
        bool isKanji = false;
        UINT c = 0;
        while ( (c = *(p++)) != '\0') 
        {
            if ( ! isKanji )
            {
                if ( IsKanji(c) || IsHankaku(c) )
                {
                    *(r++) = ESC;
                    *(r++) = '$';
                    *(r++) = 'B';
                    if ( IsKanji(c) )
                    {
                        UINT d = *(p++);
                        ms_SjisToJis(&c, &d);
                        *(r++) = static_cast<BYTE>(c);
                        *(r++) = static_cast<BYTE>(d);
                    }
                    else
                    {
                        WORD e;
                        int rc = ms_HanToZen(e, p - 1);
                        if ( rc != 1 )
                        {
                            p++;
                        }
                        *(r++) = static_cast<BYTE>((e >> 8) & 0xff);
                        *(r++) = static_cast<BYTE>(e & 0xff);
                    }
                    isKanji = true;
                } 
                else 
                {
                    *(r++) = static_cast<BYTE>(c);
                }
            }
            else
            {
                if ( ! IsKanji(c) && ! IsHankaku(c) )
                {
                    *(r++) = ESC;
                    *(r++) = '(';
                    *(r++) = 'B';
                    *(r++) = static_cast<BYTE>(c);
                    isKanji = false;
                }
                else 
                {
                    if ( IsKanji(c) )
                    {
                        UINT d = *(p++);
                        ms_SjisToJis(&c, &d);
                        *(r++) = static_cast<BYTE>(c);
                        *(r++) = static_cast<BYTE>(d);
                    }
                    else
                    {
                        WORD e;
                        int rc = ms_HanToZen(e, p - 1);
                        if (rc != 1) 
                        {
                            p++;
                        }
                        *(r++) = static_cast<BYTE>((e >> 8) & 0xff);
                        *(r++) = static_cast<BYTE>(e & 0xff);
                    }
                }
            }
        }
        if ( isKanji ) 
        {
            *(r++) = ESC;
            *(r++) = '(';
            *(r++) = 'B';
        }
        *r = '\0';
        return r - reinterpret_cast<BYTE*>(pIso2022);
    }
    /*
     * [変換] JISの2バイトをSJISに変換
     *  @param[in,out] ph 上位BYTE
     *  @param[in,out] pl 下位BYTE
     */
    static void ms_JisToSjis(UINT* ph, UINT* pl)
    {
        if ( (*ph & 1) != 0 )
        {
            if ( *pl < 0x60 )
            {
                *pl += 0x1F;
            }
            else
            {
                *pl += 0x20;
            }
        }
        else
        {
            *pl += 0x7E;
        }
        if ( *ph < 0x5F )
        {
            *ph = (*ph + 0xE1) >> 1;
        } 
        else 
        {
            *ph = (*ph + 0x161) >> 1;
        }
    }
    static INT_PTR ms_Iso2022jpToSjis(LPCSTR pIso2022, LPSTR pSjis)
    {
        LPCSTR p = pIso2022;
        LPSTR r = pSjis;
        int j = 0;
        bool jiskanji = false;
        bool hankaku = false;
        while ( *p != '\0')
        {
            j++;
            UINT c = *(p++);
            UINT d;
            if ( c == ESC )
            {
                if ( *p == '\0' )
                {
                    break;
                }
                if ( (c = *(p++)) == '$' )
                {
                    if ( (c = *(p++)) == '@' || c == 'B' )
                    {
                        jiskanji = true;
                    }
                    else 
                    {
                        *(r++) = ESC;
                        *(r++) = '$';
                        if ( c != '\0' )
                        {
                            *(r++) = static_cast<BYTE>(c);
                        }
                    }
                }
                else if ( c == '(' )
                {
                    if ( (c = *(p++)) == 'H' || c == 'J' || c == 'B' )
                    {
                        jiskanji = false;
                    }
                    else
                    {
                        jiskanji = false;
                        *(r++) = ESC;
                        *(r++) = '(';
                        if ( c != '\0' )
                        {
                            *(r++) = static_cast<BYTE>(c);
                        }
                    }
                }
                else if ( c == '*' )
                {
                    if ( (c = *(p++)) == 'B' )
                    {
                        hankaku = false;
                    }
                    else if ( c == 'I' )
                    {
                        hankaku = false;
                    }
                }
                else if ( hankaku && c == 'N' )
                {
                    c = *(p++);
                    *(r++) = static_cast<BYTE>(c + 0x80);
                }
                else if ( c == 'K' )
                {
                    jiskanji = true;
                }
                else if ( c == 'H' )
                {
                    jiskanji = false;
                }
                else
                {
                    *(r++) = ESC;
                    if ( c != '\0' )
                    {
                        *(r++) = static_cast<BYTE>(c);
                    }
                }
            }
            else if ( jiskanji && (c == '\r' || c == '\n') )
            {
                jiskanji = false;
                *(r++) = static_cast<BYTE>(c);
            }
            else if ( jiskanji && c >= 0x21 && c <= 0x7E )
            {
                if ( *p == '\0' )
                {
                    break;
                }
                if ( (d = *(p++)) >= 0x21 && d <= 0x7E )
                {
                    ms_JisToSjis(&c, &d);
                }
                *(r++) = static_cast<BYTE>(c);
                if ( d != '\0' )
                {
                    *(r++) = static_cast<BYTE>(d);
                }
            }
            else if ( c >= 0xA1 && c <= 0xFE )
            {
                if ( *p == '\0' )
                {
                    break;
                }
                if ( (d = *(p++)) >= 0xA1 && d <= 0xFE )
                {
                    d &= 0x7E;
                    c &= 0x7E;
                    ms_JisToSjis(&c, &d);
                }
                *(r++) = static_cast<BYTE>(c);
                if ( d != '\0' )
                {
                    *(r++) = static_cast<BYTE>(d);
                }
            }
            else if ( c == 0x0E )
            {
                while ( *p != '\0' && *p != 0x0F && *p != '\r' && *p != '\n' && *p != ESC )
                {
                    *(r++) = static_cast<BYTE>(*(p++) + 0x80);
                }
                if ( *p == 0x0F )
                {
                    p++;
                }
            }
            else
            {
                *(r++) = static_cast<BYTE>(c);
            }
        }
        *r = '\0';
        return r - pSjis;
    }
public:
 
    CJisStr(void)
    {
    }
 
    CJisStr(const CJisStr& other) : m_vtcText(other.m_vtcText)
    {
    }
 
    CJisStr(LPCSTR lpszJis)
    {
        SetOfJis(lpszJis);
    }
 
    CJisStr(const CAscii& ascii)
    {
        SetOfAscii(ascii);
    }
 
    CJisStr(const CUnicode& unicode)
    {
        SetOfUnicode(unicode);
    }
 
    CJisStr& operator=(const CJisStr& other)
    {
        m_vtcText = other.m_vtcText;
        return *this;
    }
 
    virtual INT_PTR Compare(const CJisStr& t) const
    {
        return STRLIB::Compare(ReferBuffer(), t.ReferBuffer());
    }
 
    void Empty(void)
    {
        m_vtcText.Empty();
    }
 
    bool IsEmpty(void) const
    {
        return GetLength() == 0;
    }
 
    void SetOfJis(LPCSTR lpszJis)
    {
        if ( lpszJis == NULL )
        {
            Empty();
        }
        else
        {
            size_t iSize = STRLIB::GetLen(lpszJis);
            MemCopy(m_vtcText.GetBuffer(iSize + 1), lpszJis, iSize + 1);
            m_vtcText.ReleaseBuffer();
        }
    }
 
    void SetOfUnicode(LPCWSTR lpszUnicode)
    {
        SetOfAscii(CAscii(lpszUnicode));
    }
 
    void SetOfAscii(LPCSTR lpszAscii)
    {
        TTRACE0("SJIS 文字列を JIS 文字列に変換\n");
        if ( lpszAscii != NULL )
        {
            size_t len = STRLIB::GetLen(lpszAscii);
            if ( len > 0 )
            {
                INT_PTR r = ms_SjisToIso2022jp(lpszAscii, m_vtcText.GetBuffer(len * 4 + 1));
                ASSERT( r < static_cast<INT_PTR>(len * 4 + 1));
                m_vtcText.ReleaseBuffer();
                return;
            }
        }
        Empty();
    }
 
    CJisStr& operator+=(const CJisStr& j)
    {
        m_vtcText += j.m_vtcText;
        return *this;
    }
 
    CJisStr operator+(const CJisStr& j) const
    {
        CJisStr newJis = *this;
        newJis += j;
        return newJis;
    }
 
    size_t GetLength(void) const
    {
        return STRLIB::GetLen(ReferBuffer());
    }
 
    CUnicode ToUnicode(void) const { return CUnicode(ToAscii()); }
 
    CAscii ToAscii(void) const
    {
        TTRACE0("Jis 文字列を S-JIS文字列に変換\n");
        CAscii asc;
        size_t len = m_vtcText.GetLength();
        size_t r = ms_Iso2022jpToSjis(m_vtcText, asc.GetBuffer(len));
        ASSERT( r < len );
        asc.ReleaseBuffer();
        return asc;
    }
 
    CStr ToStr(void) const { return CStr(ToAscii()); }
 
    LPCSTR ReferBuffer(void) const
    {
        return m_vtcText;
    }
 
    operator LPCSTR (void) const
    {
        return ReferBuffer();
    }
 
    LPSTR GetBuffer(int iLength)
    {
        return m_vtcText.GetBuffer(iLength);
    }
 
    void ReleaseBuffer(void)
    {
        m_vtcText.ReleaseBuffer();
        CJisStr s;
        s.SetOfJis(m_vtcText);
        m_vtcText = s.m_vtcText;
    }
 
    static CJisStr ToJis(LPCSTR lpszAscii)
    {
        CJisStr j;
        j.SetOfAscii(lpszAscii);
        return j;
    }
};
 
 
 
}; // TNB
 
 
 
//T-TestCaseコードカバレッジEnable
#pragma comment(user,"T-Coverage Enable")