CFile.cpp

[詳解]

//=============================================================================
/// @file
/// ファイル入出力クラス実装ファイル
///
/// ファイル入出力クラス実装ファイルです。
///
/// $Id: CFile.cpp 245 2019-03-20 15:03:41Z admin $
/// $Date: 2019-03-21 00:03:41 +0900 (2019/03/21 (木)) $
/// $Author: admin $
///
/// @attention なし

#pragma managed( push, off )

//=============================================================================
// インポートライブラリ
#pragma comment( lib, "shlwapi.lib" )

//=============================================================================
// インクルードファイル
#include <CFile.h>
#include <LibUtility.h>
#include <shlwapi.h>
#include <mbctype.h>

//=============================================================================
// 共通ライブラリ名前空間
namespace LibCommon {
    //=========================================================================
    // ファイル入出力クラス
    //=========================================================================
    // 構築子と解体子
    //-------------------------------------------------------------------------
    // コンストラクタ
    CFile::CFile() noexcept
        // メンバ変数初期化
        : m_hFile( nullptr )
        , m_uCodePage( CP_UTF16 )
    {}

    //-------------------------------------------------------------------------
    // デストラクタ
    CFile::~CFile() noexcept {
        // クローズする
        Close();
    }

    //=========================================================================
    // 公開関数
    //-------------------------------------------------------------------------
    // 作成関数
    bool CFile::Create( wchar_t const* pszPath, UINT uCodePage ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // ファイルハンドルを調べる
            if ( nullptr != m_hFile ) {
                // クローズする
                Close();
            }

            // ファイルを読み書き用に新規作成する
            m_hFile = ::CreateFileW( pszPath, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_ARCHIVE, nullptr );
            if ( INVALID_HANDLE_VALUE == m_hFile ) {
                // 失敗！
                m_hFile = nullptr;
                break;
            }
            // BOMを出力する
            else if ( !OutputBom( m_uCodePage ) ) {
                // クローズする
                Close();

                // 失敗！
                break;
            }

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // オープン関数
    bool CFile::Open( wchar_t const* pszPath, bool bWrite ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // ファイルハンドルを調べる
            if ( nullptr != m_hFile ) {
                // クローズする
                Close();
            }

            // 書き込み許可フラグを調べる
            if ( bWrite ) {
                // ファイルを読み書き用でオープンする
                m_hFile = ::CreateFileW( pszPath, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_ARCHIVE, nullptr );
            }
            else {
                // ファイルを読み取り専用でオープンする
                m_hFile = ::CreateFileW( pszPath, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_ARCHIVE, nullptr );
            }

            // ファイルハンドルを調べる
            if ( INVALID_HANDLE_VALUE == m_hFile ) {
                // 失敗！
                m_hFile = nullptr;
                break;
            }

            // コードページを入力する
            int nUtf8;
            int nSJis;
            if ( !InputCodePage( m_uCodePage, nUtf8, nSJis ) ) {
                // コードページ種別を設定する
                m_uCodePage = CP_ACP;
            }

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // 追記モードオープン関数
    bool CFile::OpenAppend( wchar_t const* pszPath, UINT uCodePage ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // ファイルハンドルを調べる
            if ( nullptr != m_hFile ) {
                // クローズする
                Close();
            }

            // ファイルの有無を調べる
            bool bExist = false;
            if ( 0 != ::PathFileExistsW( pszPath ) ) {
                // 既存ファイルフラグをセットする
                bExist = true;
            }

            // ファイルを読み書き用にオープンまたは新規作成する
            m_hFile = ::CreateFileW( pszPath, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_ALWAYS, FILE_ATTRIBUTE_ARCHIVE, nullptr );

            // ファイルハンドルを調べる
            if ( INVALID_HANDLE_VALUE == m_hFile ) {
                // 失敗！
                m_hFile = nullptr;
                break;
            }
            // 既存ファイルフラグを調べる
            else if ( bExist ) {
                // コードページを入力する
                int nUtf8;
                int nSJis;
                if ( !InputCodePage( m_uCodePage, nUtf8, nSJis ) ) {
                    // コードページ種別を設定する
                    m_uCodePage = CP_ACP;
                }
            }
            else {
                // コードページを設定する
                m_uCodePage = uCodePage;

                // BOMを出力する
                if ( !OutputBom( m_uCodePage ) ) {
                    // クローズする
                    Close();

                    // 失敗！
                    break;
                }
            }

            // ファイルポインタを設定する
            SetFilePoint( GetFileSize() );

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // クローズ関数
    void CFile::Close() noexcept {
        // 処理ブロック
        do {
            // ファイルハンドルをクローズする
            ::CloseHandle( m_hFile );
            m_hFile = nullptr;
        } while ( false );
    }

    //-------------------------------------------------------------------------
    // リード関数
    LONGLONG CFile::Read( void* pBuffer, LONGLONG nSize ) noexcept {
        // 処理ブロック
        LONGLONG result = 0;
        do {
            // バッファポインタを調べる
            if ( nullptr == pBuffer ) {
                // 失敗！
                break;
            }
            // リードサイズを調べる
            else if ( 0 > nSize ) {
                // 失敗！
                break;
            }

            // ファイルポインタを保存する
            LONGLONG nPoint = GetFilePoint();

            // 巡回する
            LONGLONG nTotal = 0;
            BYTE*&   rpByte = reinterpret_cast< BYTE*& >( pBuffer );
            for ( ;; ) {
                // リードサイズを調べる
                if ( 0 == nSize ) {
                    // 成功！
                    result = nTotal;
                    break;
                }

                // リードサイズを設定する
                DWORD dwRead = static_cast< DWORD >( nSize );
                if ( UINT_MAX < nSize ) {
                    dwRead = UINT_MAX;
                }

                // ファイルをリードする
                DWORD dwCount;
                if ( 0 == ::ReadFile( m_hFile, rpByte, dwRead, &dwCount, nullptr ) ) {
                    // 失敗！
                    break;
                }
                // リードサイズを調べる
                else if ( dwRead != dwCount ) {
                    // 失敗！
                    break;
                }

                // 作業変数を更新する
                nSize  -= dwCount;
                nTotal += dwCount;
                rpByte += dwCount;
            }

            // 実行結果を調べる
            if ( 0 == result ) {
                // ファイルポインタを復元する
                SetFilePoint( nPoint );
            }
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // ライト関数
    LONGLONG CFile::Write( void const* pBuffer, LONGLONG nSize ) noexcept {
        // 処理ブロック
        LONGLONG result = 0;
        do {
            // バッファポインタを調べる
            if ( nullptr == pBuffer ) {
                // 失敗！
                break;
            }
            // ライトサイズを調べる
            else if ( 0 > nSize ) {
                // 失敗！
                break;
            }

            // ファイルポインタを保存する
            LONGLONG nPoint = GetFilePoint();

            // 巡回する
            LONGLONG     nTotal = 0;
            BYTE const*& rpByte = reinterpret_cast< BYTE const*& >( pBuffer );
            for ( ;; ) {
                // ライトサイズを調べる
                if ( 0 == nSize ) {
                    // 成功！
                    result = nTotal;
                    break;
                }

                // 残りサイズを調べる
                DWORD dwWrite = static_cast< DWORD >( nSize );
                if ( UINT_MAX < nSize ) {
                    dwWrite = UINT_MAX;
                }

                // ファイルにライトする
                DWORD dwCount;
                if ( 0 == ::WriteFile( m_hFile, rpByte, dwWrite, &dwCount, nullptr ) ) {
                    // 失敗！
                    break;
                }
                // ライトサイズを調べる
                else if ( dwWrite != dwCount ) {
                    // 失敗！
                    break;
                }

                // 作業変数を更新する
                nSize  -= dwCount;
                nTotal += dwCount;
                rpByte += dwCount;
            }

            // 実行結果を調べる
            if ( 0 == result ) {
                // ファイルポインタを復元する
                SetFilePoint( nPoint );
            }
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // ファイルサイズ取得関数
    LONGLONG CFile::GetFileSize() const noexcept {
        // 処理ブロック
        LONGLONG result = 0;
        do {
            // ファイルサイズを取得する
            LARGE_INTEGER sSize;
            if ( 0 == ::GetFileSizeEx( m_hFile, &sSize ) ) {
                // 失敗！
                break;
            }

            // 成功！
            result = sSize.QuadPart;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // ファイルポインタ取得関数
    LONGLONG CFile::GetFilePoint() const noexcept {
        // 処理ブロック
        LONGLONG result = 0;
        do {
            // ファイルポインタを取得する
            static LARGE_INTEGER const sMove = {};
            LARGE_INTEGER              sPoint;
            if ( 0 == ::SetFilePointerEx( m_hFile, sMove, &sPoint, FILE_CURRENT ) ) {
                // 失敗！
                break;
            }

            // 成功！
            result = sPoint.QuadPart;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // ファイルポインタ設定関数
    bool CFile::SetFilePoint( LONGLONG nPoint ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // ファイルポインタを設定する
            LARGE_INTEGER sPoint;
            sPoint.QuadPart = nPoint;
            if ( 0 == ::SetFilePointerEx( m_hFile, sPoint, nullptr, FILE_BEGIN ) ) {
                // 失敗！
                break;
            }

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // ファイル終端設定関数
    bool CFile::SetFileEnd() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // ファイル終端を設定する
            if ( 0 == ::SetEndOfFile( m_hFile ) ) {
                // 失敗！
                break;
            }

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // コードバイトリード関数
    bool CFile::ReadCodeBytes( unsigned char pBuffer[ MB_LEN_MAX ], int& nCount, int nSize ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // リードサイズを調べる
            if ( nCount < nSize ) {
                // 不足バイトをリードする
                nCount += static_cast< int >( Read( &pBuffer[ nCount ], nSize - nCount ) );
                if ( nSize > nCount ) {
                    // 失敗！
                    break;
                }
            }

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // コードページ入力関数
    bool CFile::InputCodePage( UINT& ruCodePage, int& rnUtf8, int& rnSJis ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // コードページ確率引数を初期化する
            rnUtf8 = 0;
            rnSJis = 0;

            // ファイルポインタを保存する
            LONGLONG nPoint = GetFilePoint();

            // ファイルポインタを設定する
            SetFilePoint( 0 );

            // 処理ブロック
            unsigned char pBuffer[ MB_LEN_MAX ];
            int           nCount = 0;
            int           nSize  = 0;
            do {
                // UTF-16のBOMコードを取得する
                unsigned char const* pBom = GetBomData( CP_UTF16, nSize );
                if ( nullptr != pBom ) {
                    // BOMコードデータをリードする
                    if ( !ReadCodeBytes( pBuffer, nCount, nSize ) ) {
                        // 失敗！
                        break;
                    }
                    // BOMコードデータを調べる
                    else if ( 0 != ::memcmp( pBom, pBuffer, nSize ) ) {
                        // 失敗！
                        break;
                    }

                    // 成功！
                    result = true;
                    break;
                }

                // UTF-8のBOMコードを取得する
                pBom = GetBomData( CP_UTF8, nSize );
                if ( nullptr != pBom ) {
                    // BOMコードデータをリードする
                    if ( !ReadCodeBytes( pBuffer, nCount, nSize ) ) {
                        // 失敗！
                        break;
                    }
                    // BOMコードデータを調べる
                    else if ( 0 != ::memcmp( pBom, pBuffer, nSize ) ) {
                        // 失敗！
                        break;
                    }

                    // 成功！
                    result = true;
                    break;
                }
            } while ( false );

            // 実行結果を調べる
            if ( result ) {
                // 開始時のファイルポインタを調べる
                if ( nSize < nPoint ) {
                    // ファイルポインタを復元する
                    SetFilePoint( nPoint );
                }

                // 終了！
                break;
            }

            // コードページらしさカウントをクリアする
            int nSeemUtf8 = 0;
            int nSeemSJis = 0;

            // 巡回する
            for ( bool bContinue = false;; bContinue = true ) {
                // コンティニューか調べる
                if ( bContinue ) {
                    // リードカウントを調べる
                    if ( 0 < nCount ) {
                        // リードカウントをデクリメントする
                        if ( 0 < --nCount ) {
                            // バイトコードバッファを１バイト分シフトする
                            if ( 0 != ::memmove_s( pBuffer, sizeof pBuffer, &pBuffer[ 1 ], nCount ) ) {
                                // 失敗！
                                break;
                            }
                        }
                    }
                }

                // １バイトリードする
                if ( !ReadCodeBytes( pBuffer, nCount, 1 ) ) {
                    // 失敗！
                    break;
                }
                // 第１バイトがアスキーコードか調べる
                else if ( IsAscii( pBuffer[ 0 ] ) ) {
                    // 続ける！
                    continue;
                }

                // 処理ブロック
                bool bIsUtf8 = true;
                bool bIsSJis = true;
                do {
                    // 第１バイトがS-JIS確定半角カナか調べる
                    if ( IsConfirmedKanaSjis( pBuffer[ 0 ] ) ) {
                        // UTF-8コード可能性フラグをクリアする
                        bIsUtf8 = false;

                        // 終了！
                        break;
                    }
                    // 第１バイトがS-JIS第１バイトか調べる
                    else if ( IsFirstByteSjis( pBuffer[ 0 ] ) ) {
                        // 第２バイトをリードして、
                        // S-JIS第２バイトでないか調べる
                        if ( !ReadCodeBytes( pBuffer, nCount, 2 ) || !IsSecondByteSjis( pBuffer[ 1 ] ) ) {
                            // S-JISコード可能性フラグをクリアする
                            bIsSJis = false;
                        }
                        // 第１バイトがS-JIS確定第１バイトか調べる
                        else if ( IsConfirmedFirstByteSjis( pBuffer[ 0 ] ) ) {
                            // UTF-8コード可能性フラグをクリアする
                            bIsUtf8 = false;

                            // 終了！
                            break;
                        }
                    }
                    // 第１バイトがS-JISカナでないか調べる
                    else if ( !IsKanaSjis( pBuffer[ 0 ] ) ) {
                        // S-JISコード可能性フラグをクリアする
                        bIsSJis = false;
                    }

                    // UTF-8コードサイズを取得する
                    if ( !GetCodeSizeUtf8( pBuffer[ 0 ], nSize ) ) {
                        // UTF-8コード可能性フラグをクリアする
                        bIsUtf8 = false;
                    }
                    // UTF-8コードサイズを調べる
                    else if ( 4 <= nSize ) {
                        // S-JISコード可能性フラグをクリアする
                        bIsSJis = false;
                    }
                    // S-JIS可能性フラグを調べる
                    else if ( bIsSJis ) {
                        // 第１バイトがS-JIS第１バイトか調べる
                        unsigned char ch;
                        if ( IsFirstByteSjis( pBuffer[ 0 ] ) ) {
                            // 第３バイトを調べる
                            ch = pBuffer[ 2 ];
                        }
                        else {
                            // 第２バイトを調べる
                            ch = pBuffer[ 1 ];
                        }

                        // 文字コードがS-JIS第１バイトでなく、
                        // かつS-JIS半角カナでもないか調べる
                        if ( !IsFirstByteSjis( ch ) && !IsKanaSjis( ch ) ) {
                            // S-JISコード可能性フラグをクリアする
                            bIsSJis = false;
                        }
                    }
                } while ( false );

                // UTF-8フラグを調べる
                if ( bIsUtf8 ) {
                    // S-JISフラグを調べる
                    if ( !bIsSJis ) {
                        // 成功！
                        ruCodePage     = CP_UTF8;
                        result = true;
                        break;
                    }

                    // UTF-8コードらしさカウンタをインクリメントする
                    ++nSeemUtf8;
                }

                // S-JISフラグを調べる
                if ( bIsSJis ) {
                    // UTF-8フラグを調べる
                    if ( !bIsUtf8 ) {
                        // 成功！
                        ruCodePage     = CP_ACP;
                        result = true;
                        break;
                    }

                    // S-JISコードらしさカウンタをインクリメントする
                    ++nSeemSJis;
                }
            }

            // 実行結果を調べる
            if ( !result ) {
                // コードページ確率を計算する
                int nSeemTotal = ( nSeemUtf8 + nSeemSJis );
                if ( 0 < nSeemTotal ) {
                    rnUtf8 = static_cast< int >( 100.0 * nSeemUtf8 / nSeemTotal );
                    rnSJis = static_cast< int >( 100.0 * nSeemSJis / nSeemTotal );
                }
            }

            // ファイルポインタを復元する
            SetFilePoint( nPoint );
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // BOM出力関数
    bool CFile::OutputBom( UINT uCodePage ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // コードページ種別を調べる
            void const* pBom = nullptr;
            int         nSize;
            if ( CP_ACP == uCodePage ) {
                // 成功！
                result = true;
                break;
            }
            else if ( CP_UTF16 == uCodePage ) {
                // UTF-16コードページBOMデータを取得する
                pBom = GetBomData( CP_UTF16, nSize );
            }
            else if ( CP_UTF8 == uCodePage ) {
                // UTF-8コードページBOMデータを取得する
                pBom = GetBomData( CP_UTF8, nSize );
            }

            // BOMデータポインタを調べる
            if ( nullptr == pBom ) {
                // 失敗！
                break;
            }

            // ファイルポインタを保存する
            LONGLONG nPoint = GetFilePoint();

            // ファイルポインタを設定する
            SetFilePoint( 0 );

            // BOMバイトをライトする
            if ( nSize == static_cast< int >( Write( pBom, nSize ) ) ) {
                // 成功！
                result = true;

                // 開始時のファイルポインタを調べる
                if ( nSize >= static_cast< int >( nPoint ) ) {
                    // 終了！
                    break;
                }
            }

            // ファイルポインタを復元する
            SetFilePoint( nPoint );
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //=========================================================================
    // 静的公開関数
    //-------------------------------------------------------------------------
    // BOMデータ取得関数
    char unsigned const* CFile::GetBomData( UINT uCodePage, int& nSize ) noexcept {
        // 処理ブロック
        char unsigned const* result = nullptr;
        do {
            // コードページ種別を調べる
            static char unsigned const BOM_UTF16[] = { 0xFF, 0xFE };
            static char unsigned const BOM_UTF8[]  = { 0xEF, 0xBB, 0xBF };
            if ( CP_UTF16 == uCodePage ) {
                // 成功！
                nSize   = sizeof BOM_UTF16;
                result = BOM_UTF16;
            }
            else if ( CP_UTF8 == uCodePage ) {
                // 成功！
                nSize   = sizeof BOM_UTF8;
                result = BOM_UTF8;
            }
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // ASCIIコード判定関数
    bool CFile::IsAscii( char unsigned ch ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 文字コードを調べる
            result = ( 0x7F >= ch );
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // S-JIS第１バイト判定関数
    bool CFile::IsFirstByteSjis( char unsigned ch ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 文字コードを調べる
            result = ( 0 != ::_ismbblead( ch ) );
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // S-JIS第２バイト判定関数
    bool CFile::IsSecondByteSjis( char unsigned ch ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 文字コードを調べる
            result = ( 0 != ::_ismbbtrail( ch ) );
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // S-JIS確定第１バイト判定関数
    bool CFile::IsConfirmedFirstByteSjis( char unsigned ch ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 文字コードを調べる
            result = ( ( 0x80 <= ch ) && ( 0x9F >= ch ) );
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // S-JIS半角カナ判定関数
    bool CFile::IsKanaSjis( char unsigned ch ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 文字コードを調べる
            result = ( 0 != ::_ismbbkana( ch ) );
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // S-JIS確定半角カナ判定関数
    bool CFile::IsConfirmedKanaSjis( char unsigned ch ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 文字コードを調べる
            result = ( ( 0xA0 <= ch ) && ( 0xC1 >= ch ) );
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // Unicode半角カナ判定関数
    bool CFile::IsKanaUnicode( wchar_t ch ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 文字コードを調べる
            result = ( ( ch <= 0xFF61 ) && ( ch >= 0xFF9F ) );
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // UTF-8コードサイズ取得関数
    bool CFile::GetCodeSizeUtf8( char unsigned ch, int& nSize ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 第１バイトコードを調べる
            if ( IsAscii( ch ) ) {
                nSize = 1;
            }
            else if ( 0xC0 == ( 0xE0 & ch ) ) {
                nSize = 2;
            }
            // ３バイトコードの１バイト目か調べる
            else if ( 0xE0 == ( 0xF0 & ch ) ) {
                nSize = 3;
            }
            // ４バイトコードの１バイト目か調べる
            else if ( 0xF0 == ( 0xF8 & ch ) ) {
                nSize = 4;
            }
            // ５バイトコードの１バイト目か調べる
            else if ( 0xF8 == ( 0xFC & ch ) ) {
                nSize = 5;
            }
            // ６バイトコードの１バイト目か調べる
            else if ( 0xFC == ( 0xFE & ch ) ) {
                nSize = 6;
            }
            else {
                // 失敗！
                break;
            }

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }
}

#pragma managed( pop )