// MyFile.cpp : インプリメンテーション ファイル // #include "stdafx.h" #include "renshu_unicode.h" #include "MyFile.h" #include #include "MyString.h" #ifdef _DEBUG #define new DEBUG_NEW #undef THIS_FILE static char THIS_FILE[] = __FILE__; #endif ///////////////////////////////////////////////////////////////////////////// // CMyFile グローバル変数 enum { UNKNOWN, MSB1st, LSB1st } byteOrder ; ///////////////////////////////////////////////////////////////////////////// // CMyFile CMyFile::CMyFile(CString filePath) { m_filePath = filePath ; } CMyFile::CMyFile() { // CWinApp* pApp = AfxGetApp() ; // m_filePath = pApp->GetProfileString( "Recent File List" ,"File1" ); } CMyFile::~CMyFile() { } BEGIN_MESSAGE_MAP(CMyFile, CWnd) //{{AFX_MSG_MAP(CMyFile) // メモ - ClassWizard はこの位置にマッピング用のマクロを追加または削除します。 //}}AFX_MSG_MAP END_MESSAGE_MAP() ///////////////////////////////////////////////////////////////////////////// // CMyFile メッセージ ハンドラ /*------------------------------------------------------------------------*/ /* */ /* 関数名 | GetReadFileName */ /* */ /* 戻り値 | CString m_filePath : 選択されたファイルの path 名を返す。*/ /* */ /* 処理内容 | ファイル名選択ダイアログで、１個のファイルを取得。 filter を" 全てのファイル(*.*)\0*.*\0\0"に仮定する。*/ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ CString CMyFile::GetReadFileName() { m_filePath = GetReadFileName( _T(" 全てのファイル(*.*)\0*.*\0\0") ); return m_filePath ; } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | GetReadFileName */ /* 引数 */ /* 入力 | char * filter : ファイル選択 filter を指定する。 */ /* */ /* 戻り値 | CString m_filePath : 選択されたファイルの path 名を返す。*/ /* */ /* 処理内容 | ファイル名選択ダイアログで、１個のファイルを取得。 */ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ CString CMyFile::GetReadFileName(WCHAR *filter) { CWinApp* pApp = AfxGetApp() ; int n ,j ; WCHAR szDefExt[16] ,szTemp[1024] ,fileTitle[1024] ; OPENFILENAME ofn ; n = 0 ; while( n < 512 ) { if ( filter[n] == '|' ) { n++ ; break ; } n++ ; } j = 0 ; while( n < 512 ) { szDefExt[j] = filter[n] ; szDefExt[j + 1] = 0 ; if ( filter[n] == '|' ) { szDefExt[j] = 0; n++ ; break ; } n++ ; j++ ; } n = lstrlen( szDefExt ); for ( j = 0 ; j < n ; j++ ) { if ( szDefExt[j] == '.' ) { break ; } } if ( j >= n ) { j = 0 ; } lstrcpy( szTemp ,m_filePath ); n = lstrlen( szTemp ); while( n > 0 ) { n-- ; if ( szTemp[n] == '\\' ) { lstrcpy( &szTemp[n + 1] ,szDefExt ); break ; } } if ( szDefExt[j + 1] == '*' ) { szDefExt[j] = 0 ; } // OPENFILENAME 構造体の設定 ofn.lStructSize = sizeof(ofn); // OPENFILENAME ); ofn.hwndOwner = 0 ; ofn.hInstance = 0 ; ofn.lpstrFilter = filter ; ofn.lpstrCustomFilter = 0 ; ofn.nMaxCustFilter = 0 ; ofn.nFilterIndex = 1 ; ofn.lpstrFile = szTemp; ofn.nMaxFile = 512 ; ofn.lpstrFileTitle = fileTitle ; ofn.nMaxFileTitle = 256 ; ofn.lpstrInitialDir = 0 ; ofn.lpstrTitle = _T( "WinMemo_can ユーティリティ" ); ofn.Flags = OFN_FILEMUSTEXIST | OFN_EXPLORER ; ofn.nFileOffset = 0 ; ofn.nFileExtension = 0 ; ofn.lpstrDefExt = &szDefExt[j]; if ( ::GetOpenFileName( &ofn ) ) { m_filePath = szTemp ; // pApp->AddToRecentFileList( m_filePath ); return m_filePath ; } else { return _T( "" ); } } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | GetFilePath */ /* メンバー変数 */ /* 入力 | CString m_filePath : ファイルの path 名を指定する。 */ /* */ /* 戻り値 | CString m_filePath : 内部で記憶している path 名を返す。 */ /* */ /* 処理内容 | 内部で記憶している path 名を取得する。 */ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ CString CMyFile::GetFilePath() { return m_filePath ; } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | GetSaveFileName */ /* */ /* 戻り値 | CString m_filePath : 選択されたファイルの path 名を返す。*/ /* */ /* 処理内容 | ファイル名選択ダイアログで、１個のファイルを取得。 書き込み用として、ファイルの path 名を取得する。 filter を" 全てのファイル(*.*)\0*.*\0\0"に仮定する。*/ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ CString CMyFile::GetSaveFileName() { m_filePath = GetSaveFileName( _T(" 全てのファイル(*.*)\0*.*\0\0") ); return m_filePath ; } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | GetSaveFileName */ /* 引数 */ /* 入力 | char * filter : ファイル選択 filter を指定する。 */ /* */ /* 戻り値 | CString m_filePath : 選択されたファイルの path 名を返す。*/ /* */ /* 処理内容 | ファイル名選択ダイアログで、１個のファイルを取得。 書き込み用として、ファイルの path 名を取得する。 */ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ CString CMyFile::GetSaveFileName(WCHAR * filter) { CWinApp* pApp = AfxGetApp() ; int n ,j ; WCHAR szDefExt[16] ,szTemp[1024] ,fileTitle[1024] ; OPENFILENAME ofn ; // CMyString myStr ; // CString strBuff ; n = 0 ; while( n < 512 ) { if ( filter[n] == '|' ) { n++ ; break ; } n++ ; } j = 0 ; while( n < 512 ) { szDefExt[j] = filter[n] ; szDefExt[j + 1] = 0 ; if ( filter[n] == '|' ) { szDefExt[j] = 0 ; n++ ; break ; } n++ ; j++ ; } n = lstrlen( szDefExt ); for ( j = 0 ; j < n ; j++ ) { if ( szDefExt[j] == '.' ) { break ; } } if ( j >= n ) { j = 0 ; } // myStr.strcpy_s( szTemp ,sizeof( szTemp ) ,m_filePath ); lstrcpy(szTemp, m_filePath); n = lstrlen( szTemp ); while( n > 0 ) { n-- ; if ( szTemp[n] == '\\' ) { lstrcpy( &szTemp[n + 1] ,szDefExt ); break ; } } if ( szDefExt[j + 1] == '*' ) { szDefExt[j] = 0 ; } // OPENFILENAME 構造体の設定 ofn.lStructSize = sizeof( OPENFILENAME ) ; ofn.hwndOwner = 0 ; ofn.hInstance = 0 ; // strBuff = filter ; ofn.lpstrFilter = filter ; ofn.lpstrCustomFilter = 0 ; ofn.nMaxCustFilter = 0 ; ofn.nFilterIndex = 1 ; ofn.lpstrFile = szTemp ; ofn.nMaxFile = 512 ; ofn.lpstrFileTitle = fileTitle ; ofn.nMaxFileTitle = 256 ; ofn.lpstrInitialDir = 0 ; ofn.lpstrTitle = _T( "WinMemo ユーティリティ" ) ; ofn.Flags = OFN_EXPLORER | OFN_OVERWRITEPROMPT ; // OFN_FILEMUSTEXIST | OFN_EXPLORER ; ofn.nFileOffset = 0 ; ofn.nFileExtension = 0 ; ofn.lpstrDefExt = &szDefExt[j] ; if ( ::GetSaveFileNameW( &ofn ) ) { m_filePath = szTemp ; // pApp->AddToRecentFileList( m_filePath ); return m_filePath ; } else { return _T( "" ); } } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | file_read */ /* 引数 */ /* 入力 | char *fileName : ファイルの path 名を指定する。 */ /* 出力 | char **lpBuff : 読み込んだ data を保存する。 */ /* */ /* 戻り値 | unsigned long nRead : 読み込んだ data 長( Byte ) */ /* */ /* 処理内容 | ファイル名を指定して、data を読み込む。 */ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ DWORD CMyFile::file_read(char *fileName, char **lpBuff) { DWORD dwFileSize ; unsigned long nRead ; HANDLE hReadFile ; CString strWork ,strBuff ,strFileName ; strFileName = fileName ; if ( (hReadFile = CreateFile( strFileName ,GENERIC_READ ,0 ,NULL , OPEN_EXISTING ,0 ,NULL )) == INVALID_HANDLE_VALUE ) { strWork.LoadString( IDS_FILE_OPEN_ERR ); strBuff.Format( _T("%s\r\n\r\n%s") ,strFileName ,strWork ); CWnd::MessageBox (strBuff , _T("file_read") ,MB_OK); return FALSE ; } // Get the size of the file. dwFileSize = GetFileSize(hReadFile, NULL); if (dwFileSize == 0xFFFFFFFF) { strWork.LoadString( IDS_GET_FILE_SIZE_ERR ); strBuff.Format( _T("%s\r\n\r\n%s") ,strFileName ,strWork ); CWnd::MessageBox (strBuff , _T("file_read") ,MB_OK); return FALSE ; } dwFileSize += 16 ; // Allocate a buffer for the file to be read into. *lpBuff = (char *)GlobalAlloc( GMEM_FIXED, dwFileSize ); if (lpBuff == NULL) { strWork.LoadString( IDS_MEM_ALLOC_ERR ); strBuff.Format( _T("%s\r\n\r\n%s") ,strFileName ,strWork ); CWnd::MessageBox (strBuff , _T("file_read") ,MB_OK); CloseHandle( hReadFile ); return FALSE ; } if ( !ReadFile( hReadFile ,(LPVOID)*lpBuff ,dwFileSize ,&nRead ,NULL) ) { /* handle error */ strWork.LoadString( IDS_READ_FILE_ERR ); strBuff.Format( _T("%s\r\n\r\n%s") ,strFileName ,strWork ); CWnd::MessageBox (strBuff , _T("file_read") ,MB_OK); CloseHandle( hReadFile ); return FALSE ; } CloseHandle(hReadFile); return (nRead) ; } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | file_read */ /* 引数 */ /* 出力 | char **lpBuff : 読み込んだ data を保存する。 */ /* */ /* メンバー変数 */ /* 入力 | CString m_filePath : ファイルの path 名を指定する。 */ /* */ /* 戻り値 | unsigned long nRead : 読み込んだ data 長( Byte ) */ /* */ /* 処理内容 | ファイル名を指定して、data を読み込む。 */ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ DWORD CMyFile::file_read(char **lpBuff) { char fileName[1024] ; CMyString myStr ; myStr.strcpy_s( fileName ,sizeof(fileName) ,m_filePath ); return file_read( fileName ,lpBuff ); } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | file_read */ /* メンバー変数 */ /* 入力 | CString m_filePath : ファイルの path 名を指定する。 */ /* */ /* 戻り値 | char *lpBuff : 読み込んだ data を保存する。 */ /* */ /* 処理内容 | ファイル名を指定して、data を読み込む(data長が不明) */ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ char* CMyFile::file_read() { char fileName[1024] ; char *lpBuff ; CMyString myStr ; myStr.strcpy_s( fileName ,sizeof( fileName ) ,m_filePath ); file_read( fileName ,&lpBuff ); return lpBuff ; } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | GetFileName */ /* メンバー変数 */ /* 入力 | CString m_filePath : ファイルの path 名を指定する。 */ /* */ /* 戻り値 | CString fileName : ディレクトリを除いたファイル名を返す。*/ /* */ /* 処理内容 | フルパス名からファイル名を取得する。 */ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ CString CMyFile::GetFileName() { return GetFileName( m_filePath ); } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | GetFileName */ /* 引数 */ /* 入力 | CString filePath : ファイルの path 名を指定する。 */ /* */ /* 戻り値 | CString fileName : ディレクトリを除いたファイル名を返す。*/ /* */ /* 処理内容 | フルパス名からファイル名を取得する。 */ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ CString CMyFile::GetFileName(CString filePath) { CString fileName ; int n ; fileName = _T( "" ); n = filePath.GetLength(); while ( n > 0 ) { n-- ; if ( filePath.Mid( n ,1 ).Compare( _T( "\\" ) ) == 0 ) { fileName = filePath.Mid( n + 1 ); break ; } } return fileName ; } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | file_read */ /* 引数 */ /* 入力 | CString fileName : ファイルの path 名を指定する。 */ /* 出力 | char **lpBuff : 読み込んだ data を保存する。 */ /* */ /* 戻り値 | unsigned long nRead : 読み込んだ data 長( Byte ) */ /* */ /* 処理内容 | ファイル名を指定して、data を読み込む。 */ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ DWORD CMyFile::file_read(CString fileName, char **lpBuff) { char fname[1024] ; CMyString myStr ; myStr.strcpy_s( fname ,sizeof( fname ) ,fileName ); return file_read( fname ,lpBuff ); } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | file_write */ /* 引数 */ /* 入力 | char *fname : ファイルの path 名を指定する。 */ /* 入力 | DWORD nChar : 書き込む data 長(Byte)を指定する*/ /* 入力 | char **lpBuff : 書き込む data を指定する。 */ /* */ /* 戻り値 | unsigned long nWrite : 書き込んだ data 長( Byte ) */ /* */ /* 処理内容 | ファイル名を指定して、data を書き込む。 */ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ DWORD CMyFile::file_write(char *fname, DWORD nChar, char **lpBuff) { unsigned long nWrite ; HANDLE hWriteFile ; CString strWork ,strFileName ; strFileName = fname ; if ( (hWriteFile = CreateFile( strFileName ,GENERIC_WRITE ,0 ,NULL , CREATE_ALWAYS ,0 ,NULL )) == INVALID_HANDLE_VALUE ) { // handle error strWork.LoadString( IDS_FILE_OPEN_ERR ); CWnd::MessageBox (strWork ,_T("file_write") ,MB_OK); return FALSE ; } if (!WriteFile(hWriteFile, (LPBYTE) *lpBuff , nChar , &nWrite , NULL)) { // handle error strWork.LoadString( IDS_WRITE_FILE_ERR ); CWnd::MessageBox (strWork ,_T("file_write") ,MB_OK); } CloseHandle(hWriteFile); return nWrite ; } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | file_write */ /* 引数 */ /* 入力 | CString fileName : ファイルの path 名を指定する。 */ /* 入力 | DWORD nChar : 書き込む data 長(Byte)を指定する*/ /* 入力 | char **lpBuff : 書き込む data を指定する。 */ /* */ /* 戻り値 | unsigned long nWrite : 書き込んだ data 長( Byte ) */ /* */ /* 処理内容 | ファイル名を指定して、data を書き込む。 */ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ DWORD CMyFile::file_write(CString fileName, DWORD nChar, char **lpBuff) { char fname[1024] ; CMyString myStr ; myStr.strcpy_s( fname ,sizeof( fname ) ,fileName ); return file_write( fname ,nChar ,lpBuff ); } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | file_write */ /* 引数 */ /* 入力 | DWORD nChar : 書き込む data 長(Byte)を指定する*/ /* 入力 | char **lpBuff : 書き込む data を指定する。 */ /* */ /* メンバー変数 */ /* 入力 | CString m_filePath : ファイルの path 名を指定する。 */ /* */ /* 戻り値 | unsigned long nWrite : 書き込んだ data 長( Byte ) */ /* */ /* 処理内容 | ファイル名を指定して、data を書き込む。 */ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ DWORD CMyFile::file_write(DWORD nChar, char **lpBuff) { char fname[1024] ; CMyString myStr ; myStr.strcpy_s( fname ,sizeof( fname ) ,m_filePath ); return file_write( fname ,nChar ,lpBuff ); } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | isFile */ /* 引数 */ /* 入力 | CString filePath : ファイルの path 名を指定する。 */ /* */ /* 戻り値 | BOOL retFlg : FALSE ファイルなし TRUE ファイルありを返す。 */ /* */ /* 処理内容 | 指定されたファイルが存在するかを調べる。 */ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ BOOL CMyFile::isFile(CString filePath) { // char fileName[1024] ; HANDLE hReadFile ; // CMyString myStr; // myStr.strcpy_s( fileName ,sizeof( fileName ) ,filePath ); if ( (hReadFile = CreateFile( filePath ,GENERIC_READ ,0 ,NULL , OPEN_EXISTING ,0 ,NULL )) == INVALID_HANDLE_VALUE ) { return FALSE ; } else { CloseHandle(hReadFile); return TRUE ; } } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | SetDirPathName */ /* 引数 */ /* 入力 | CString strDirPath : メンバー変数に設定するパス名。 */ /* */ /* メンバー変数 */ /* 出力 | CString m_filePath : ファイルの path 名を指定する。 */ /* */ /* 戻り値 | 無し */ /* */ /* 処理内容 | メンバー変数の m_filePath を設定する。 */ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ void CMyFile::SetDirPathName(CString strDirPath) { m_filePath = strDirPath ; } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | CSVDiv */ /* 引数 */ /* 入力 | CString csvData : 変換元data */ /* 出力 | CString *divData : 抜き出しdata(最大 65536 個まで)*/ /* */ /* 戻り値 | 無し */ /* */ /* 処理内容 | ,(カンマ）区切りの CSV data を分割する。 */ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ int CMyFile::CSVDiv(CString csvData, CString *divData) { int i ,j ,k ,n ; // char cr ,cb ,cf ; int cr, cb, cf; i = 0 ; n = csvData.GetLength() ; j = 0 ; k = 0 ; while ( ( i < n ) && ( k < 65536 ) ) { switch ( csvData.GetAt( i ) ) { case '\"': i++ ; while ( i < n ) { cb = csvData.GetAt( i - 1 ); cr = csvData.GetAt( i ) ; cf = csvData.GetAt( i + 1 ); if ( ( cr == '\"' ) && ( cf == '\"' ) ) { i++ ; } else if ( ( cr == '\"' ) && ( cb != '\\' ) ) { break ; } i++ ; } break ; case ',': if ( i - j ) { divData[k++] = csvData.Mid( j ,i - j ); } else { divData[k++].Empty() ; } j = i + 1 ; break ; } i++ ; } if ( i - j ) { divData[k++] = csvData.Mid( j ,i - j ); } else { divData[k++].Empty() ; } return k ; } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | setByteOrder */ /* グローバル変数 */ /* 出力 | enum { UNKNOWN, MSB1st, LSB1st } byteOrder */ /* */ /* 戻り値 | 無し */ /* */ /* 処理内容 | エンディアン(LSB1st or MSB1st)を自動検出する。 */ /* 制御タイミング | byteReverse から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ void CMyFile::setByteOrder() { union { unsigned short int usi; unsigned char uc[2]; } w; w.usi = 0x1234; if (w.uc[0] == 0x12) byteOrder = MSB1st; else byteOrder = LSB1st; } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | byteReverse */ /* 引数 */ /* 入力／出力 | unsigned char *buf : 変換data */ /* 入力 | unsigned int longs : 変換data長(DWORD(4 Byte)) */ /* */ /* グローバル変数 */ /* 入力／出力 | enum { UNKNOWN, MSB1st, LSB1st } byteOrder */ /* */ /* 戻り値 | 無し */ /* */ /* 処理内容 | リトル・エンディアン(LSB1st)のとき、データ並べ替える*/ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ void CMyFile::byteReverse(unsigned char *buf, unsigned int longs) { unsigned long t; if (byteOrder == UNKNOWN) setByteOrder(); if (byteOrder == LSB1st) return; do { t = (unsigned long) ((unsigned) buf[3] << 24 | buf[2]) << 16 | ((unsigned) buf[1] << 8 | buf[0]); *(unsigned long *) buf = t; buf += 4; } while (--longs); } /*------------------------------------------------------------------------*/ /* This code implements the MD5 message-digest algorithm. */ /* The algorithm is due to Ron Rivest. This code was */ /* * written by Colin Plumb in 1993, no copyright is claimed. */ /* This code is in the public domain; do with it what you wish. */ /* */ /* Equivalent code is available from RSA Data Security, Inc. */ /* This code has been tested against that, and is equivalent, */ /* except that you don't need to include two pages of legalese */ /* with every copy. */ /* */ /* To compute the message digest of a chunk of bytes, declare an */ /* MD5Context structure, pass it to MD5Init, call MD5Update as */ /* needed on buffers full of bytes, and then call MD5Final, which */ /* will fill a supplied 16-byte array with the digest. */ /*------------------------------------------------------------------------*/ /*------------------------------------------------------------------------*/ /* Start MD5 accumulation. Set bit count to 0 and buffer to mysterious */ /* initialization constants. */ /* */ /* 関数名 | MD5Init */ /* 引数 */ /* 入力／出力 | MD5Context *ctx : MD5 コンテキスト */ /* */ /* 戻り値 | 無し */ /* */ /* 処理内容 | MD5 コンテキストを初期化する。 */ /* 制御タイミング | md5 から内部呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ void CMyFile::MD5Init(MD5Context *ctx) { ctx->buf[0] = 0x67452301; ctx->buf[1] = 0xefcdab89; ctx->buf[2] = 0x98badcfe; ctx->buf[3] = 0x10325476; ctx->bits[0] = 0; ctx->bits[1] = 0; } /*------------------------------------------------------------------------*/ /* Update context to reflect the concatenation of another buffer full */ /* of bytes. */ /* */ /* 関数名 | MD5Update */ /* 引数 */ /* 入力／出力 | MD5Context *ctx : MD5 コンテキスト */ /* 入力 | const unsigned char *buf : 入力data */ /* 入力 | unsigned int len : 入力data長(Byte) */ /* */ /* 戻り値 | 無し */ /* */ /* 処理内容 | MD5 コンテキストをアップデートする。 */ /* 制御タイミング | md5 から内部呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ void CMyFile::MD5Update(MD5Context *ctx, const unsigned char *buf, unsigned int len) { unsigned long t; /* Update bitcount */ t = ctx->bits[0]; if ((ctx->bits[0] = t + ((unsigned long) len << 3)) < t) { ctx->bits[1]++; /* Carry from low to high */ } ctx->bits[1] += len >> 29; t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */ /* Handle any leading odd-sized chunks */ if (t) { unsigned char *p = (unsigned char *) ctx->in + t; t = 64 - t; if (len < t) { memcpy(p, buf, len); return; } memcpy(p, buf, t); byteReverse(ctx->in, 16); MD5Transform(ctx->buf, (unsigned long *) ctx->in); buf += t; len -= t; } /* Process data in 64-byte chunks */ while (len >= 64) { memcpy(ctx->in, buf, 64); byteReverse(ctx->in, 16); MD5Transform(ctx->buf, (unsigned long *) ctx->in); buf += 64; len -= 64; } /* Handle any remaining bytes of data. */ memcpy(ctx->in, buf, len); } /*------------------------------------------------------------------------*/ /* Final wrapup - pad to 64-byte boundary with the bit pattern */ /* 1 0* (64-bit count of bits processed, MSB-first) */ /* */ /* 関数名 | MD5Final */ /* 引数 */ /* 入力 | unsigned char digest[] : 出力data ダイジェスト */ /* 入力／出力 | MD5Context *ctx : MD5 コンテキスト */ /* */ /* 戻り値 | 無し */ /* */ /* 処理内容 | MD5 コンテキストの最終処理をする。 */ /* 制御タイミング | md5 から内部呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ void CMyFile::MD5Final(unsigned char digest[], MD5Context *ctx) { unsigned count; unsigned char *p; /* Compute number of bytes mod 64 */ count = (ctx->bits[0] >> 3) & 0x3F; /* Set the first char of padding to 0x80. This is safe since there is always at least one byte free */ p = ctx->in + count; *p++ = 0x80; /* Bytes of padding needed to make 64 bytes */ count = 64 - 1 - count; /* Pad out to 56 mod 64 */ if (count < 8) { /* Two lots of padding: Pad the first block to 64 bytes */ memset(p, 0, count); byteReverse(ctx->in, 16); MD5Transform(ctx->buf, (unsigned long *) ctx->in); /* Now fill the next block with 56 bytes */ memset(ctx->in, 0, 56); } else { /* Pad block to 56 bytes */ memset(p, 0, count - 8); } byteReverse(ctx->in, 14); /* Append length in bits and transform */ ((unsigned long *) ctx->in)[14] = ctx->bits[0]; ((unsigned long *) ctx->in)[15] = ctx->bits[1]; MD5Transform(ctx->buf, (unsigned long *) ctx->in); byteReverse((unsigned char *) ctx->buf, 4); memcpy(digest, ctx->buf, 16); memset(ctx, 0, sizeof(ctx)); /* In case it's sensitive */ } /*------------------------------------------------------------------------*/ /* The core of the MD5 algorithm, this alters an existing MD5 hash to */ /* reflect the addition of 16 longwords of new data. MD5Update blocks */ /* the data and converts bytes into longwords for this routine. */ /* */ /* 関数名 | MD5Transform */ /* 引数 */ /* 出力 | unsigned long buf[] : 変換結果data */ /* 入力 | const unsigned long in[] : 変換元data */ /* */ /* 戻り値 | 無し */ /* */ /* 処理内容 | MD5 コンテキストの変換をする。 */ /* 制御タイミング | MD5Final から内部呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ void CMyFile::MD5Transform(unsigned long buf[], const unsigned long in[]) { register unsigned long a, b, c, d; a = buf[0]; b = buf[1]; c = buf[2]; d = buf[3]; MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7); MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12); MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17); MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22); MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7); MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12); MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17); MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22); MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7); MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12); MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17); MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22); MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7); MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12); MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17); MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22); MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5); MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9); MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14); MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20); MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5); MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9); MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14); MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20); MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5); MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9); MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14); MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20); MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5); MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9); MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14); MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20); MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4); MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11); MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16); MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23); MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4); MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11); MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16); MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23); MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4); MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11); MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16); MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23); MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4); MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11); MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16); MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23); MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6); MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10); MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15); MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21); MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6); MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10); MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15); MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21); MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6); MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10); MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15); MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21); MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6); MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10); MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15); MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21); buf[0] += a; buf[1] += b; buf[2] += c; buf[3] += d; } /* 以下 451との差分 */ /*------------------------------------------------------------------------*/ /* */ /* 関数名 | Get_motROMData */ /* 引数 */ /* 入力 | char *fname : ファイルの path 名を指定する。 */ /* 出力 | char * romdata : ROM領域 data を指定する。 */ /* */ /* 戻り値 | BOOL retFlg : FALSE エラーあり TRUE エラーなし */ /* */ /* 処理内容 | ファイル名を指定して、モトローラ(S) data を読み込む */ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ BOOL CMyFile::Get_motROMData(char *fname, char *romdata) { HANDLE hReadFile ; char *lpBufPtr; DWORD dwFileSize ,nRead ,fp ; unsigned long int i ,j ,k ,n ,addr ; char buff[512] ,work[64] ; char *ptr[2] ; BOOL retFlg ; CString strFileName ; strFileName = fname ; if ( (hReadFile = CreateFile( strFileName ,GENERIC_READ ,0 ,NULL , OPEN_EXISTING ,0 ,NULL )) == INVALID_HANDLE_VALUE ) { MessageBox (_T("ファイルオープンに失敗しました") , _T("Get_motROMData 実行中") ,MB_OK); return FALSE ; } // Get the size of the file. dwFileSize = GetFileSize(hReadFile, NULL); if (dwFileSize == 0xFFFFFFFF) { MessageBox( _T("ファイルサイズ取得に失敗しました!") , _T("Get_motROMData 実行中") , MB_OK); return FALSE ; } // Allocate a buffer for the file to be read into. lpBufPtr = (char *)GlobalAlloc( GMEM_FIXED, dwFileSize ); if (lpBufPtr == NULL) { MessageBox(_T("メモリが取得できません!") , _T("Get_motROMData 実行中") , MB_OK); CloseHandle( hReadFile ); return FALSE ; } if ( !ReadFile( hReadFile ,(LPVOID)lpBufPtr ,dwFileSize ,&nRead ,NULL) ) { /* handle error */ MessageBox (_T("ファイル読み込みに失敗しました") , _T("Get_motROMData 実行中") , MB_OK); CloseHandle( hReadFile ); return FALSE ; } CloseHandle(hReadFile); retFlg = TRUE ; for ( i = 0 ; i < nRead ; i++ ) { n = lpBufPtr[i] ; n &= 0x00ff ; if ( (n != '\r') && (n != '\n') && (n != '\t') && (n != 0x0c) && (n < 0x20) ) { retFlg = FALSE ; GlobalFree(lpBufPtr); return retFlg ; } } retFlg = FALSE ; fp = 0 ; while (fp < nRead) { while ((lpBufPtr[fp] != 'S') && (fp < nRead)) { fp++ ; } if (fp >= nRead) { break ; } i = 0 ; while ((lpBufPtr[fp] != ASCII_LF) && (fp < nRead) && (i < 512)) { buff[i] = lpBufPtr[fp] ; fp++ ; i++ ; } if ( i > 510 ) { break ; } if (memcmp( buff ,"S1" ,2 ) == 0) { strcpy_s( work ,sizeof( work ) ,"00000000" ); memcpy( &work[6] ,&buff[2] ,2 ); n = strtol( work ,ptr ,16 ); n = n - 3 ; strcpy_s( work, sizeof(work),"00000000" ); memcpy( &work[4] ,&buff[4] ,4 ); addr = strtol( work ,ptr ,16 ); for ( i = 0 ; i < n ; i++ ) { j = i * 2 + 8 ; k = addr + i ; strcpy_s( work, sizeof(work),"00000000" ); memcpy( &work[6] ,&buff[j] ,2 ); romdata[k] = (unsigned char) strtol( work ,ptr ,16 ); } retFlg = TRUE ; } if (memcmp(buff ,"S2" ,2 ) == 0) { strcpy_s( work, sizeof(work),"00000000" ); memcpy( &work[6] ,&buff[2] ,2 ); n = strtol( work ,ptr ,16 ); n = n - 4 ; strcpy_s( work, sizeof(work),"00000000" ); memcpy( &work[2] ,&buff[4] ,6 ); addr = strtol( work ,ptr ,16 ); if ( addr >= 0x007c0000 ) { addr |= 0x007c0000 ; } addr &= 0x007fffff ; for ( i = 0 ; i < n ; i++ ) { j = i * 2 + 10; k = addr + i ; strcpy_s( work, sizeof(work),"00000000" ); memcpy( &work[6] ,&buff[j] ,2 ); if ( k < 0x00800000 ) { romdata[k] = (unsigned char) strtol( work ,ptr ,16 ); } } retFlg = TRUE ; } if (memcmp(buff ,"S3" ,2 ) == 0) { strcpy_s( work, sizeof(work),"00000000" ); memcpy( &work[6] ,&buff[2] ,2 ); n = strtol( work ,ptr ,16 ); n = n - 5 ; strcpy_s( work, sizeof(work),"00000000" ); memcpy( &work[0] ,&buff[4] ,8 ); addr = strtoul( work ,ptr ,16); if ( addr >= 0x007c0000 ) { addr |= 0x007c0000 ; } addr &= 0x007fffff ; for ( i = 0 ; i < n ; i++ ) { j = i * 2 + 12; k = addr + i; strcpy_s( work, sizeof(work),"00000000" ); memcpy( &work[6] ,&buff[j] ,2); if ( k < 0x00800000 ) { romdata[k] = (unsigned char) strtol( work ,ptr ,16 ); } } retFlg = TRUE ; } } GlobalFree(lpBufPtr); return(retFlg) ; } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | Clear_ROMData */ /* 引数 */ /* 出力 | char *romData : ROM領域data */ /* 入力 | DWORD saddr : 開始アドレス */ /* 入力 | DWORD eaddr : 終了アドレス */ /* */ /* 戻り値 | 無し */ /* */ /* 処理内容 | ROM領域dataを 0xff で初期化する。 */ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ void CMyFile::Clear_ROMData(char *romData, DWORD saddr, DWORD eaddr) { DWORD addr ; for ( addr = saddr ; addr <= eaddr ; addr++ ) { romData[addr] = (char)0x00ff ; } } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | Get_motROMData */ /* 引数 */ /* 入力 | CString fileName : ファイルの path 名を指定する。 */ /* 出力 | char * romdata : ROM領域 data を指定する。 */ /* */ /* 戻り値 | BOOL retFlg : FALSE エラーあり TRUE エラーなし */ /* */ /* 処理内容 | ファイル名を指定して、モトローラ(S) data を読み込む */ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ BOOL CMyFile::Get_motROMData(CString fileName, char *romdata) { char fname[1024]; CMyString myStr ; myStr.strcpy_s( fname ,sizeof( fname ) ,fileName ); return Get_motROMData( fname ,romdata ); } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | s0_put */ /* 引数 */ /* 入力 | char *fname : 出力ファイル・パスを指定する。 */ /* */ /* メンバー変数 */ /* 出力／入力 | HANDLE m_hWriteFile : 出力用ファイル・ハンドル */ /* */ /* 戻り値 | BOOL retFlg : FALSE : 失敗 TRUE : 成功 */ /* */ /* 処理内容 | モトローラ(S)形式、S0 ヘッダーを出力する。 */ /* 制御タイミング | PutmotROMData から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ BOOL CMyFile::s0_put(char *fname) { char buff[256] ,bin[256] ; DWORD ik ; int i ,k ,n ,c ,sum ; k = strlen(fname) + 3 ; strcpy_s(buff ,sizeof( buff ) ,"S0") ; bin[0] = k ; bin[1] = 0 ; bin[2] = 0 ; strcpy_s(&bin[3] ,sizeof( bin ) - 4 ,fname) ; sum = 0 ; for (i = 0 ; i < k ; i++ ) { sum = sum + bin[i] ; } sum = sum & 0x00ff ; bin[k] = 255 - sum ; k++ ; for (i = 0 ; i < k ; i++ ) { n = i * 2 + 2 ; c = bin[i] ; c = c & 0x000000ff ; sprintf_s( &buff[n] ,sizeof( buff ) - n - 1 ,"%02X",c ) ; } n++ ; n++ ; sprintf_s(&buff[n] ,sizeof( buff ) - n - 1 ,"\r\n"); n++ ; n++ ; if (!WriteFile(m_hWriteFile, (LPBYTE)buff , n , &ik , NULL)) { /* handle error */ MessageBox (_T("ファイル書き込みに失敗しました") , _T("s0_put 実行中") ,MB_OK); return FALSE ; } return(TRUE) ; } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | rombts_3 */ /* 引数 */ /* 入力 | char *romdata : ROM領域 data を指定する。 */ /* 入力 | DWORD saddr : 開始アドレスを指定する。 */ /* 入力 | DWORD eaddr : 終了アドレスを指定する。 */ /* */ /* メンバー変数 */ /* 出力／入力 | HANDLE m_hWriteFile : 出力用ファイル・ハンドル */ /* */ /* 戻り値 | BOOL retFlg : FALSE : 失敗 TRUE : 成功 */ /* */ /* 処理内容 | ROM領域 data をモトローラ(S)形式に変換とファイルに １レコード毎に出力する。 */ /* 制御タイミング | Put_motROMData から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ BOOL CMyFile::rombts_3(char *romdata, DWORD saddr, DWORD eaddr) { int n ,c ,i ,sum ,chk ; unsigned int offset ,size ,ln ,addr ,romAddr ; char buff[256] ,work[256] ,bin[256] ; DWORD ik ; offset = saddr ; size = eaddr - saddr + 1 ; for (ln = 0 ; ln < size ; ln += 32 ) { buff[0] = 'S' ; buff[1] = '3' ; addr = ln + offset ; if ((saddr <= addr) && (addr <= eaddr)) { memcpy(work ,&addr ,4 ) ; bin[0] = 37 ; bin[1] = work[3] ; bin[2] = work[2] ; bin[3] = work[1] ; bin[4] = work[0] ; sum = 0 ; for (i = 0 ; i < 5 ; i++ ) { sum += bin[i] ; } chk = 0 ; // chk = 1 ; for (i = 0 ; i < 32 ; i++ ) { if ( addr >= 0x00800000 ) { romAddr = ( addr | 0x007c0000 ) & 0x007fffff ; } else { romAddr = addr ; } c = (int) romdata[romAddr] ; c &= 0x00ff ; if (c != 255) { chk = 0 ; } n = i + 5 ; bin[n] = c ; sum += bin[n] ; addr++ ; } if (chk == 0) { sum &= 0x000000ff ; bin[37] = 255 - sum ; for (i = 0 ; i < 38 ; i++ ) { n = i * 2 + 2 ; c = bin[i] ; c &= 0x000000ff ; sprintf_s(&buff[n] ,sizeof( buff ) ,"%02X" ,c ) ; } n++ ; n++ ; sprintf_s(&buff[n] ,sizeof( buff ) ,"\r\n"); n++ ; n++ ; if (!WriteFile(m_hWriteFile, (LPBYTE)buff , n , &ik , NULL)) { /* handle error */ MessageBox (_T("ファイル書き込みに失敗しました") , _T("rombts_2 実行中") ,MB_OK); return FALSE ; } } } } return(TRUE) ; } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | Put_motROMData */ /* 引数 */ /* 入力 | char *fileName : 出力ファイル・パスを指定する。 */ /* 入力 | char *romdata : ROM領域 data を指定する。 */ /* 入力 | DWORD saddr : 開始アドレスを指定する。 */ /* 入力 | DWORD eaddr : 終了アドレスを指定する。 */ /* */ /* メンバー変数 */ /* 出力／入力 | HANDLE m_hWriteFile : 出力用ファイル・ハンドル */ /* */ /* 戻り値 | BOOL retFlg : FALSE : 失敗 TRUE : 成功 */ /* */ /* 処理内容 | ROM領域 data をモトローラ(S)形式でファイルに出力する。*/ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ BOOL CMyFile::Put_motROMData(char *fileName, char *romdata, DWORD saddr, DWORD eaddr) { char szTemp[1024] ; DWORD i ,n ; CString strFileName ; // CWnd* ppWnd ; // lstrcpy(szViewName ,"C:\\WINDOWS\\Notepad.exe" ); strFileName = fileName ; if ( (m_hWriteFile = CreateFile( strFileName ,GENERIC_WRITE ,0 ,NULL , CREATE_ALWAYS ,0 ,NULL )) == INVALID_HANDLE_VALUE ) { /* handle error */ MessageBox (_T("ファイルオープンに失敗しました") , _T("Put_motROMData 実行中") ,MB_OK); return FALSE ; } else { s0_put( fileName ); rombts_3( romdata ,saddr ,eaddr ); strcpy_s(szTemp ,sizeof( szTemp ) ,"S70500000000FA\r\n"); n = strlen(szTemp) ; if (WriteFile(m_hWriteFile, (LPBYTE)szTemp , n , &i , NULL)) { CloseHandle(m_hWriteFile); // ppWnd = AfxGetMainWnd( ); // if ( 32 >= (int) ShellExecute(ppWnd->GetSafeHwnd() , // "open" , // szViewName , // fileName , // "c:\\windows\\temp" , // SW_SHOW )) { // MessageBox ("プロセス作成に失敗しました。やり直してください。" , // "Put_motROMData 実行中" ,MB_OK); // } return ( TRUE ) ; } else { /* handle error */ MessageBox (_T("ファイル書き込みに失敗しました") , _T("Put_motROMData 実行中") ,MB_OK); return FALSE ; } CloseHandle(m_hWriteFile); return TRUE ; } } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | Put_motROMData */ /* 引数 */ /* 入力 | CString fName : 出力ファイル・パスを指定する。 */ /* 入力 | char *romdata : ROM領域 data を指定する。 */ /* 入力 | DWORD saddr : 開始アドレスを指定する。 */ /* 入力 | DWORD eaddr : 終了アドレスを指定する。 */ /* */ /* メンバー変数 */ /* 出力／入力 | HANDLE m_hWriteFile : 出力用ファイル・ハンドル */ /* */ /* 戻り値 | BOOL retFlg : FALSE : 失敗 TRUE : 成功 */ /* */ /* 処理内容 | ROM領域 data をモトローラ(S)形式でファイルに出力する。*/ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ BOOL CMyFile::Put_motROMData(CString fName, char *romdata, DWORD saddr, DWORD eaddr) { char szTemp[1024] ,fileName[512] ; DWORD i ,n ; // CMyString myStr ; // myStr.strcpy_s( fileName ,sizeof( fName ) ,fName ); if ( (m_hWriteFile = CreateFile( fName ,GENERIC_WRITE ,0 ,NULL , CREATE_ALWAYS ,0 ,NULL )) == INVALID_HANDLE_VALUE ) { /* handle error */ MessageBox (_T("ファイルオープンに失敗しました") , _T("Put_motROMData 実行中") ,MB_OK); return FALSE ; } else { s0_put( fileName ); rombts_3( romdata ,saddr ,eaddr ); strcpy_s(szTemp ,sizeof( szTemp ) ,"S70500000000FA\r\n"); n = strlen(szTemp) ; if (WriteFile(m_hWriteFile, (LPBYTE)szTemp , n , &i , NULL)) { CloseHandle(m_hWriteFile); return ( TRUE ) ; } else { /* handle error */ MessageBox (_T("ファイル書き込みに失敗しました") , _T("Put_motROMData 実行中") ,MB_OK); return FALSE ; } } } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | Get_ihexROMData */ /* 引数 */ /* 入力 | char *fname : ファイルの path 名を指定する。 */ /* 出力 | char * romdata : ROM領域 data を指定する。 */ /* */ /* 戻り値 | bool retFlg : FALSE エラーなし TRUE エラーあり */ /* */ /* 処理内容 | ファイル名を指定して、Intel hex data を読み込む。 */ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ bool CMyFile::Get_ihexROMData(char * fname, char * romdata) { DWORD i ,j ,k ,n ,addr ,prgh ; char buff[1024] ,work[1024] ; unsigned int bin[1024] ; char *ptr[2] ; HANDLE hReadFile ; char *lpBufPtr; DWORD dwFileSize ,nRead ,fp ; bool retFlg ; CString strFileName ; strFileName = fname ; if ( (hReadFile = CreateFile( strFileName ,GENERIC_READ ,0 ,NULL , OPEN_EXISTING ,0 ,NULL )) == INVALID_HANDLE_VALUE ) { MessageBox (_T("ファイルオープンに失敗しました") , _T("Get_motROMData 実行中") ,MB_OK); return FALSE ; } // Get the size of the file. dwFileSize = GetFileSize(hReadFile, NULL); if (dwFileSize == 0xFFFFFFFF) { MessageBox( _T("ファイルサイズ取得に失敗しました!") , _T("Get_motROMData 実行中") , MB_OK); return FALSE ; } // Allocate a buffer for the file to be read into. lpBufPtr = (char *)GlobalAlloc( GMEM_FIXED, dwFileSize ); if (lpBufPtr == NULL) { MessageBox(_T("メモリが取得できません!") , _T("Get_motROMData 実行中") , MB_OK); CloseHandle( hReadFile ); return FALSE ; } if ( !ReadFile( hReadFile ,(LPVOID)lpBufPtr ,dwFileSize ,&nRead ,NULL) ) { /* handle error */ MessageBox (_T("ファイル読み込みに失敗しました") , _T("Get_motROMData 実行中") , MB_OK); CloseHandle( hReadFile ); return FALSE ; } CloseHandle(hReadFile); // retFlg = TRUE ; // for ( i = 0 ; i < nRead ; i++ ) { // n = lpBufPtr[i] ; // n &= 0x00ff ; // if ( (n != '\r') && (n != '\n') && (n != '\t') && (n != 0x0c) && (n < 0x20) ) { // retFlg = FALSE ; // GlobalFree(lpBufPtr); // return retFlg ; // } // } retFlg = FALSE ; prgh = 0 ; fp = 0 ; while (fp < nRead) { while ((lpBufPtr[fp] != ':') && (fp < nRead)) { fp++ ; } if (fp >= nRead) { break ; } i = 0 ; while ((lpBufPtr[fp] != ASCII_LF) && (fp < nRead) && (i < 1024)) { buff[i] = lpBufPtr[fp] ; fp++ ; i++ ; } if ( i > 1022 ) { break ; } n = strlen( buff ); if ( buff[0] == ':' ) { j = 0 ; for ( i = 1 ; i < n ; i += 2 ) { strcpy_s( work ,sizeof( work ) ,"00000000" ); work[6] = buff[i] ; work[7] = buff[i + 1] ; bin[j] = (unsigned int) strtol( work ,ptr ,16 ); j++ ; } if ( bin[0] > 0 ) { switch( bin[3] ) { case 0x02: prgh = (bin[4] * 256 + bin[5]) * 0x10 ; break ; case 0x04: prgh = (bin[4] * 256 + bin[5]) * 0x10000 ; break ; case 0x05: prgh = bin[4] * 0x01000000 + bin[5] * 0x00010000 + bin[6] * 0x0100 + bin[7] ; break ; case 0x00: case 0x81: k = bin[0] ; addr = bin[1] * 256 + bin[2] + prgh ; for ( i = 0 ; i < k ; i++ ) { if ( ( addr + i ) < 0x00400000 ) { romdata[addr + i] = bin[i + 4] ; } } retFlg = TRUE ; break ; } } } } GlobalFree(lpBufPtr); return retFlg ; } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | Get_ihexROMData */ /* 引数 */ /* 出力 | char * romdata : ROM領域 data を指定する。 */ /* */ /* メンバー変数 */ /* 入力 | CString m_filePath : ファイルの path 名を指定する。 */ /* */ /* 戻り値 | bool retFlg : FALSE エラーなし TRUE エラーあり */ /* */ /* 処理内容 | ファイル名を指定して、Intel hex data を読み込む。 */ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ bool CMyFile::Get_ihexROMData(char * romdata) { char fname[2048] ; CMyString myStr ; myStr.strcpy_s( fname ,sizeof( fname ) ,m_filePath ); return Get_ihexROMData( fname ,romdata ); } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | Get_ihexROMData */ /* 引数 */ /* 入力 | CString fileName : ファイルの path 名を指定する。 */ /* 出力 | char * romdata : ROM領域 data を指定する。 */ /* */ /* 戻り値 | bool retFlg : FALSE エラーなし TRUE エラーあり */ /* */ /* 処理内容 | ファイル名を指定して、Intel hex data を読み込む。 */ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ bool CMyFile::Get_ihexROMData(CString fileName, char * romdata) { char fname[2048]; CMyString myStr ; myStr.strcpy_s( fname ,sizeof( fname ) ,fileName ); return Get_ihexROMData( fname ,romdata ); } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | GetMultiFileName */ /* 引数 */ /* 出力 | CString * strFileName : ファイルの path 名を指定する。 */ /* 入力 | char * filter : ファイル選択 filter を指定する。*/ /* */ /* 戻り値 | int i : 選択されたファイルの個数を返す。 */ /* */ /* 処理内容 | ファイル名選択ダイアログで、複数個のファイルを取得。*/ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ int CMyFile::GetMultiFileName(CString * strFileName, WCHAR * filter) { // CString strFil ; // strFil = filter ; CFileDialog dlgFile( TRUE ,NULL ,NULL ,OFN_FILEMUSTEXIST | OFN_ALLOWMULTISELECT | OFN_HIDEREADONLY ,filter ); POSITION pos ; BOOL isNext = FALSE ; int i ; CString fileName ; const int c_cMaxFiles = 1000 ; const int c_cbBuffSize = ( c_cMaxFiles * ( MAX_PATH + 1 ) ) + 1 ; dlgFile.GetOFN().lpstrFile = fileName.GetBuffer( c_cbBuffSize ); dlgFile.GetOFN().nMaxFile = c_cbBuffSize ; if ( dlgFile.DoModal() == IDOK ) { i = 0 ; pos = dlgFile.GetStartPosition(); while ( pos ) { if ( i < 1000 ) { strFileName[i] = dlgFile.GetNextPathName( pos ) ; i++ ; } } } return i ; } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | CSVDiv */ /* 引数 */ /* 入力 | CString csvData : 変換元data */ /* 出力 | CString *divData : 抜き出しdata(最大 65536 個まで)*/ /* 入力 | char del : 区切り文字 */ /* */ /* 戻り値 | 無し */ /* */ /* 処理内容 | 区切り文字( del )で、 CSV data を分割する。 */ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ int CMyFile::CSVDiv(CString csvData, CString *divData ,char del ) { int i ,j ,k ,n ; int cr ,cb ,cf ; // char cr, cb, cf; i = 0 ; n = csvData.GetLength() ; j = 0 ; k = 0 ; while ( ( i < n ) && ( k < 65536 ) ) { if ( csvData.GetAt( i ) == '\"' ) { i++ ; while ( i < n ) { cb = csvData.GetAt( i - 1 ); cr = csvData.GetAt( i ) ; cf = csvData.GetAt( i + 1 ); if ( ( cr == '\"' ) && ( cf == '\"' ) ) { i++ ; } else if ( ( cr == '\"' ) && ( cb != '\\' ) ) { break ; } i++ ; } } else if ( csvData.GetAt( i ) == del ) { if ( i - j ) { divData[k++] = csvData.Mid( j ,i - j ); } else { divData[k++].Empty() ; } j = i + 1 ; } i++ ; } if ( n - j ) { divData[k++] = csvData.Mid( j ,n - j ); } else { divData[k++].Empty() ; } return k ; } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | CSVDiv */ /* 引数 */ /* 入力 | CString csvData : 変換元data */ /* 出力 | CString *divData : 抜き出しdata(最大 65536 個まで)*/ /* 入力 | char del : 区切り文字 */ /* */ /* 戻り値 | 無し */ /* */ /* 処理内容 | 区切り文字( del )で、 CSV data を分割する。 このとき、" 囲みを無視する。 */ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ int CMyFile::CSVDiv_nap(CString csvData, CString * divData, char del) { int i ,j ,k ,n ; // char cr ,cb ,cf ; i = 0 ; n = csvData.GetLength() ; j = 0 ; k = 0 ; while ( ( i < n ) && ( k < 65536 ) ) { if ( csvData.GetAt( i ) == del ) { if ( i - j ) { divData[k++] = csvData.Mid( j ,i - j ); } else { divData[k++].Empty() ; } j = i + 1 ; } i++ ; } if ( n - j ) { divData[k++] = csvData.Mid( j ,n - j ); } else { divData[k++].Empty() ; } return k ; } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | loadROMData */ /* 引数 */ /* 入力 | unsigned long addr : 読み出しアドレスを指定する。 */ /* 入力 | char * romData : ROM領域 data を指定する。 */ /* */ /* 戻り値 | char retChar : 指定アドレスの ROM 値を返す。(1 Byte)*/ /* */ /* 処理内容 | 指定アドレスの ROM 値を取得する。 */ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ char CMyFile::loadROMData(unsigned long addr, char * romData) { unsigned long rAddr ; char retChar ; rAddr = addr ; if ( rAddr >= 0x007c0000 ) { rAddr |= 0x007c0000 ; } rAddr &= 0x007fffff ; retChar = romData[ rAddr ] ; return retChar ; } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | myBrowseForFolder */ /* 引数 */ /* 入力 | CString initPath : 検索開始フォルダーを指定する。 */ /* */ /* 戻り値 | CString strWork : 選択されたフォルダーの path 名を返す。*/ /* */ /* 処理内容 | BrowseForFolder を利用してフォルダーを検索選択する。*/ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ CString CMyFile::myBrowseForFolder(CString initPath) { CString strPath ,strWork ; CWinAppEx *myWinApp = new CWinAppEx ; strWork.Empty(); strPath = initPath ; // 検索フォルダーの初期化 myWinApp->GetShellManager()->BrowseForFolder( strWork ,this ,strPath , _T("フォルダーを選択して下さい:")); // if ( !strPath.IsEmpty() ) { // strWork = CString (_T("選択されたフォルダー : ")) + strPath ; // } // else { // strWork = _T( "キャンセルされた。" ) ; // } // SetDlgItemText( IDC_EDIT1 ,strWork ); return( strWork ); } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | storeROMData */ /* 引数 */ /* 入力 | unsigned long addr : 読み出しアドレスを指定する。 */ /* 入力 | char sData : ストアする data を指定する。 */ /* 入力 | char * romData : ROM領域 data を指定する。 */ /* */ /* 戻り値 | 無し */ /* */ /* 処理内容 | 指定アドレスに ROM 値をストアする。 */ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ void CMyFile::storeROMData(unsigned long addr, char sData, char * romData) { unsigned long rAddr ; rAddr = addr ; if ( rAddr >= 0x007c0000 ) { rAddr |= 0x007c0000 ; } rAddr &= 0x007fffff ; romData[ rAddr ] = sData ; } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | md5 */ /* 引数 */ /* 出力 | hexDigest : md5 結果 */ /* 入力 | lpBuff : 入力data */ /* 入力 | nRead : 入力data長(Byte) */ /* */ /* 戻り値 | 無し */ /* */ /* 処理内容 | md5 ハッシュを計算する。 */ /* 制御タイミング | ユーザー関数から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ void CMyFile::md5(char * hexDigest, char * lpBuff, unsigned int nRead) { MD5Context m_ctx ; unsigned char digest[20] ; int i ; MD5Init( (MD5Context *)&m_ctx ); MD5Update( (MD5Context *)&m_ctx ,(const unsigned char *)&lpBuff[0] ,nRead ); MD5Final( digest , (MD5Context *)&m_ctx ); for ( i = 0 ; i < 16 ; i++ ) { sprintf_s( &hexDigest[i * 2] ,10 ,"%02x" ,digest[i] ); } hexDigest[32] = 0 ; } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | rombts_2 */ /* 引数 */ /* 入力 | char *romdata : ROM領域 data を指定する。 */ /* 入力 | DWORD saddr : 開始アドレスを指定する。 */ /* 入力 | DWORD eaddr : 終了アドレスを指定する。 */ /* */ /* メンバー変数 */ /* 出力／入力 | HANDLE m_hWriteFile : 出力用ファイル・ハンドル */ /* */ /* 戻り値 | BOOL retFlg : FALSE : 失敗 TRUE : 成功 */ /* */ /* 処理内容 | ROM領域 data をモトローラ(S)形式に変換とファイルに １レコード毎に出力する。 */ /* 制御タイミング | Put_motROMData から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ BOOL CMyFile::rombts_2(char * romdata, DWORD saddr, DWORD eaddr) { int n ,c ,i ,sum ,chk ; unsigned int offset ,size ,ln ,addr ,m_saddr ,m_eaddr ,m_ramaddr ; char buff[256] ,work[256] ,bin[256] ; DWORD ik ; m_saddr = saddr ; if ( m_saddr >= 0x007c0000 ) { m_saddr |= 0x007c0000 ; } m_saddr &= 0x007fffff ; m_eaddr = eaddr ; if ( m_eaddr >= 0x007c0000 ) { m_eaddr |= 0x007c0000 ; } m_eaddr &= 0x007fffff ; offset = 0 ; size = 0x0800000 ; for (ln = 0 ; ln < size ; ln += 32 ) { buff[0] = 'S' ; buff[1] = '2' ; addr = ln + offset ; if ((m_saddr <= addr) && (addr <= m_eaddr)) { m_ramaddr = saddr + ( addr - m_saddr ) ; memcpy(work ,&m_ramaddr ,4 ) ; bin[0] = 36 ; bin[1] = work[2] ; bin[2] = work[1] ; bin[3] = work[0] ; sum = 0 ; for (i = 0 ; i < 4 ; i++ ) { sum += bin[i] ; } chk = 0 ; // chk = 1 ; for (i = 0 ; i < 32 ; i++ ) { c = (int) romdata[addr] ; c &= 0x00ff ; if (c != 255) { chk = 0 ; } n = i + 4 ; bin[n] = c ; sum += bin[n] ; addr++ ; } if (chk == 0) { sum &= 0x000000ff ; bin[36] = 255 - sum ; for (i = 0 ; i < 37 ; i++ ) { n = i * 2 + 2 ; c = bin[i] ; c &= 0x000000ff ; sprintf_s(&buff[n] ,10 ,"%02X" ,c ) ; } n++ ; n++ ; sprintf_s(&buff[n] ,10 ,"\r\n"); n++ ; n++ ; if (!WriteFile(m_hWriteFile, (LPBYTE)buff , n , &ik , NULL)) { /* handle error */ MessageBox (_T("ファイル書き込みに失敗しました") , _T("rombts_2 実行中") ,MB_OK); return FALSE ; } } } } return(TRUE) ; } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | rombts_2_16 */ /* 引数 */ /* 入力 | char *romdata : ROM領域 data を指定する。 */ /* 入力 | DWORD saddr : 開始アドレスを指定する。 */ /* 入力 | DWORD eaddr : 終了アドレスを指定する。 */ /* */ /* メンバー変数 */ /* 出力／入力 | HANDLE m_hWriteFile : 出力用ファイル・ハンドル */ /* */ /* 戻り値 | BOOL retFlg : FALSE : 失敗 TRUE : 成功 */ /* */ /* 処理内容 | ROM領域 data をモトローラ(S)形式に変換とファイルに １レコード毎に出力する。 */ /* 制御タイミング | Put_motROMData から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ BOOL CMyFile::rombts_2_16(char * romdata, DWORD saddr, DWORD eaddr) { int n ,c ,i ,sum ,chk ; unsigned int offset ,size ,ln ,addr ,m_saddr ,m_eaddr ,m_ramaddr ; char buff[256] ,work[256] ,bin[256] ; DWORD ik ; m_saddr = saddr ; if ( m_saddr >= 0x007c0000 ) { m_saddr |= 0x007c0000 ; } m_saddr &= 0x007fffff ; m_eaddr = eaddr ; if ( m_eaddr >= 0x007c0000 ) { m_eaddr |= 0x007c0000 ; } m_eaddr &= 0x007fffff ; offset = 0 ; size = 0x0800000 ; for (ln = 0 ; ln < size ; ln += 32 ) { buff[0] = 'S' ; buff[1] = '2' ; addr = ln + offset ; if ((m_saddr <= addr) && (addr <= m_eaddr)) { m_ramaddr = saddr + ( addr - m_saddr ) ; memcpy(work ,&m_ramaddr ,4 ) ; bin[0] = 36 ; bin[1] = work[2] ; bin[2] = work[1] ; bin[3] = work[0] ; sum = 0 ; for (i = 0 ; i < 4 ; i++ ) { sum += bin[i] ; } chk = 0 ; // chk = 1 ; for (i = 0 ; i < 16 ; i++ ) { c = (int) romdata[addr] ; c &= 0x00ff ; if (c != 255) { chk = 0 ; } n = i + 4 ; bin[n] = c ; sum += bin[n] ; addr++ ; } if (chk == 0) { sum &= 0x000000ff ; bin[20] = 255 - sum ; for (i = 0 ; i < 21 ; i++ ) { n = i * 2 + 2 ; c = bin[i] ; c &= 0x000000ff ; sprintf_s(&buff[n] ,10 ,"%02X" ,c ) ; } n++ ; n++ ; sprintf_s(&buff[n] ,10 ,"\r\n"); n++ ; n++ ; if (!WriteFile(m_hWriteFile, (LPBYTE)buff , n , &ik , NULL)) { /* handle error */ MessageBox (_T("ファイル書き込みに失敗しました") , _T("rombts_2 実行中") ,MB_OK); return FALSE ; } } } } return(TRUE) ; } /*------------------------------------------------------------------------*/ /* */ /* 関数名 | rombts_3_16 */ /* 引数 */ /* 入力 | char *romdata : ROM領域 data を指定する。 */ /* 入力 | DWORD saddr : 開始アドレスを指定する。 */ /* 入力 | DWORD eaddr : 終了アドレスを指定する。 */ /* */ /* メンバー変数 */ /* 出力／入力 | HANDLE m_hWriteFile : 出力用ファイル・ハンドル */ /* */ /* 戻り値 | BOOL retFlg : FALSE : 失敗 TRUE : 成功 */ /* */ /* 処理内容 | ROM領域 data をモトローラ(S)形式に変換とファイルに １レコード毎に出力する。 */ /* 制御タイミング | Put_motROMData から呼び出し */ /* 注意事項 | ---- */ /* */ /*------------------------------------------------------------------------*/ BOOL CMyFile::rombts_3_16(char * romdata, DWORD saddr, DWORD eaddr) { int n ,c ,i ,sum ,chk ; unsigned int offset ,size ,ln ,addr ,m_saddr ,m_eaddr ,m_ramaddr ; char buff[256] ,work[256] ,bin[256] ; DWORD ik ; m_saddr = saddr ; if ( m_saddr >= 0x007c0000 ) { m_saddr |= 0x007c0000 ; } m_saddr &= 0x007fffff ; m_eaddr = eaddr ; if ( m_eaddr >= 0x007c0000 ) { m_eaddr |= 0x007c0000 ; } m_eaddr &= 0x007fffff ; offset = 0 ; size = 0x0800000 ; for (ln = 0 ; ln < size ; ln += 16 ) { buff[0] = 'S' ; buff[1] = '3' ; addr = ln + offset ; if ((m_saddr <= addr) && (addr <= m_eaddr)) { m_ramaddr = ( saddr + ( addr - m_saddr ) ) ; // | 0xFF000000 ; memcpy(work ,&m_ramaddr ,4 ) ; bin[0] = 21 ; bin[1] = work[3] ; bin[2] = work[2] ; bin[3] = work[1] ; bin[4] = work[0] ; sum = 0 ; for (i = 0 ; i < 5 ; i++ ) { sum += bin[i] ; } chk = 0 ; // chk = 1 ; for (i = 0 ; i < 16 ; i++ ) { c = (int) romdata[addr] ; c &= 0x00ff ; if (c != 255) { chk = 0 ; } n = i + 5 ; bin[n] = c ; sum += bin[n] ; addr++ ; } if (chk == 0) { sum &= 0x000000ff ; bin[21] = 255 - sum ; for (i = 0 ; i < 22 ; i++ ) { n = i * 2 + 2 ; c = bin[i] ; c &= 0x000000ff ; sprintf_s(&buff[n] ,10 ,"%02X" ,c ) ; } n++ ; n++ ; sprintf_s(&buff[n] ,10 ,"\r\n"); n++ ; n++ ; if (!WriteFile(m_hWriteFile, (LPBYTE)buff , n , &ik , NULL)) { /* handle error */ MessageBox (_T("ファイル書き込みに失敗しました") , _T("rombts_2 実行中") ,MB_OK); return FALSE ; } } } } return(TRUE) ; }