📄 cmemory.cpp

📁 日本的开源编辑器源码
💻 CPP
📖 第 1 页 / 共 5 页
字号:
12 3 4 5 下一页
//	$Id: CMemory.cpp,v 1.33 2004/05/01 12:28:09 genta Exp $
/*!	@file
	メモリバッファクラス

	@author Norio Nakatani
	@date 1998/03/06 新規作成
	$Revision: 1.33 $
*/
/*
	Copyright (C) 1998-2001, Norio Nakatani
	Copyright (C) 2000-2001, jepro, genta
	Copyright (C) 2001, mik, misaka, Stonee, hor
	Copyright (C) 2002, Moca, sui
	Copyright (C) 2003, かろと

	This software is provided 'as-is', without any express or implied
	warranty. In no event will the authors be held liable for any damages
	arising from the use of this software.

	Permission is granted to anyone to use this software for any purpose, 
	including commercial applications, and to alter it and redistribute it 
	freely, subject to the following restrictions:

		1. The origin of this software must not be misrepresented;
		   you must not claim that you wrote the original software.
		   If you use this software in a product, an acknowledgment
		   in the product documentation would be appreciated but is
		   not required.

		2. Altered source versions must be plainly marked as such, 
		   and must not be misrepresented as being the original software.

		3. This notice may not be removed or altered from any source
		   distribution.
*/

#include <stdio.h>
#include <windows.h>
#include <mbstring.h>
#include <ctype.h>
#include <locale.h>
#include "CMemory.h"
#include "etc_uty.h"
#include "CEol.h"// 2002/2/3 aroka
#include "charcode.h"
#include "my_icmp.h" // Nov. 29, 2002 genta/moca

//#ifdef _DEBUG
#include "global.h"
#include "debug.h"
#include "CRunningTimer.h"
//#endif



#define ESC_JIS		"\x01b$B"
#define ESC_ASCII	"\x01b(B"
#define ESC_8BIT	"\x01b(I"

#define MIME_BASE64	1
#define MIME_QUOTED	2

#define UUDECODE_CHAR(c) ((((unsigned char)c) - ((unsigned char)32)) & (unsigned char)0x3f)

/* 文字種別 */
#define CHAR_ASCII		0	/* ASCII文字 */
#define CHAR_8BITCODE	1	/* 8ビットコード(半角カタカナなど) */
#define CHAR_ZENKAKU	2	/* 全角文字 */
#define CHAR_NULL		3	/* なにもない */



/*///////////////////////////////////////////////////////////////////////////
//
//	CMemory::CMemory
//	CMemory()
//
//	説明
//		CMemoryクラス コンストラクタ
//
///////////////////////////////////////////////////////////////////////////*/
CMemory::CMemory()
{
	m_nDataBufSize = 0;
	m_pData = NULL;
	m_nDataLen = 0;
	return;
}



/*///////////////////////////////////////////////////////////////////////////
//
//	CMemory::CMemory
//	CMemory( const char* pData, int nDataLen )
//
//	引数
//	  pData		格納データアドレス
//	  nDataLen	格納データの有効長
//
//	説明
//		CMemoryクラス  コンストラクタ
//
//
//	戻値
//		なし
//
//	備考
//		格納データにはNULLを含むことができる
//
///////////////////////////////////////////////////////////////////////////*/
CMemory::CMemory( const char* pData, int nDataLen )
{
	m_nDataBufSize = 0;
	m_pData = NULL;
	m_nDataLen = 0;
	SetData( pData, nDataLen );
	return;
}


CMemory::~CMemory()
{
	Empty();
	return;
}




const CMemory& CMemory::operator = ( char cChar )
{
	char pszChar[2];
	pszChar[0] = cChar;
	pszChar[1] = '\0';
	SetData( pszChar, 1 );
	return *this;
}


//const CMemory& CMemory::operator = ( const char* pszStr )
//{
//	SetData( pszStr, strlen( pszStr ) );
//	return *this;
//}

/******
const CMemory& CMemory::operator=( const char* pData, int nDataLen )
{
	SetData( pData, nDataLen );
	return *this;
}
*******/

const CMemory& CMemory::operator = ( const CMemory& cMemory )
{
	if( this != &cMemory ){
		SetData( (CMemory*)&(cMemory) );
	}
	return *this;
}





//const CMemory& CMemory::operator += ( const char* pszStr )
//{
//	AllocBuffer( m_nDataLen + strlen( pszStr ) );
//	AddData( pszStr, strlen( pszStr ) );
//	return *this;
//}


///* データの最後に追加 publicメンバ */
//void Append( const char* pData, int nDataLen )
//{
//	AllocBuffer( m_nDataLen + nDataLen );
//	AddData( pData, nDataLen );
//	return;
//}


const CMemory& CMemory::operator += ( const CMemory& cMemory )
{
	int			nDataLen;
	const char*	pData;
	if( this == &cMemory ){
		CMemory cm = cMemory;
		pData = cm.GetPtr( &nDataLen );
		AllocBuffer( m_nDataLen + nDataLen );
		AddData( pData, nDataLen );
	}else{
		pData = cMemory.GetPtr( &nDataLen );
		AllocBuffer( m_nDataLen + nDataLen );
		AddData( (const char*)pData, nDataLen );
	}
	return *this;
}


const CMemory& CMemory::operator += ( char ch )
{
	char szChar[2];
	szChar[0] = ch;
	szChar[1] = '\0';
	AllocBuffer( m_nDataLen + sizeof( ch ) );
	AddData( szChar, sizeof( ch ) );
	return *this;
}



//CMemory::operator char*() const
//{
//	return (char*)m_pData;
//}
//CMemory::operator const char*() const
//{
//	return (const char*)m_pData;
//}
//CMemory::operator unsigned char*() const
//{
//	return (unsigned char*)m_pData;
//}
//CMemory::operator const unsigned char*() const
//{
//	return (const unsigned char*)m_pData;
//}
//
//CMemory::operator void*() const
//{
//	return (void*)m_pData;
//}
//CMemory::operator const void*() const
//{
//	return (const void*)m_pData;
//}


/*
||  GetAt()と同機能
*/
const char CMemory::operator[](int nIndex) const
{
	if( nIndex < m_nDataLen ){
		return m_pData[nIndex];
	}else{
		return 0;
	}
}








/*
|| バッファの最後にデータを追加する（protectメンバ
*/
void CMemory::AddData( const char* pData, int nDataLen )
{
	if( NULL == m_pData ){
		return;
	}
	memcpy( &m_pData[m_nDataLen], pData, nDataLen );
	m_nDataLen += nDataLen;
	m_pData[m_nDataLen] = '\0';
	return;
}

/*!
	@brief 拡張版 SJIS→JIS変換

	SJISコードをJISに変換する．その際，JISに対応領域のないIBM拡張文字を
	NEC選定IBM拡張文字に変換する．

	Shift_JIS fa40～fc4b の範囲の文字は 8754～879a または ed40～eefc に
	散在する文字に変換された後に，JISに変換されます．
	
	@param pszSrc [in] 変換する文字列へのポインタ (Shift JIS)
	
	@author すい
	@date 2002.10.03 1文字のみ扱い，変換まで行うように変更 genta
*/
unsigned short CMemory::_mbcjmstojis_ex( unsigned char* pszSrc )
{
	unsigned int	tmpw;	/* ← int が 16 bit 以上である事を期待しています。 */
	
	if(	_IS_SJIS_1(* pszSrc    ) &&	/* Shift_JIS 全角文字の 1バイト目 */
		_IS_SJIS_2(*(pszSrc+1) )	/* Shift_JIS 全角文字の 2バイト目 */
	){	/* Shift_JIS全角文字である */
		tmpw = ( ((unsigned int)*pszSrc) << 8 ) | ( (unsigned int)*(pszSrc + 1) );
		if(
			( *pszSrc == 0x0fa ) ||
			( *pszSrc == 0x0fb ) ||
			( ( *pszSrc == 0x0fc ) && ( *(pszSrc+1) <= 0x04b ) )
		) {		/* fa40～fc4b の文字である。 */
			/* 文字コード変換処理 */
			if		  ( tmpw <= 0xfa49 ) {	tmpw -= 0x0b51;	}	/* fa40～fa49 → eeef～eef8 (ⅰ～ⅹ) */
			else	if( tmpw <= 0xfa53 ) {	tmpw -= 0x72f6;	}	/* fa4a～fa53 → 8754～875d (Ⅰ～Ⅹ) */
			else	if( tmpw <= 0xfa57 ) {	tmpw -= 0x0b5b;	}	/* fa54～fa57 → eef9～eefc (￢～＂) */
			else	if( tmpw == 0xfa58 ) {	tmpw  = 0x878a;	}	/* ㈱ */
			else	if( tmpw == 0xfa59 ) {	tmpw  = 0x8782;	}	/* № */
			else	if( tmpw == 0xfa5a ) {	tmpw  = 0x8784;	}	/* ℡ */
			else	if( tmpw == 0xfa5b ) {	tmpw  = 0x879a;	}	/* ∵ */
			else	if( tmpw <= 0xfa7e ) {	tmpw -= 0x0d1c;	}	/* fa5c～fa7e → ed40～ed62 (纊～兊) */
			else	if( tmpw <= 0xfa9b ) {	tmpw -= 0x0d1d;	}	/* fa80～fa9b → ed63～ed7e (兤～﨏) */
			else	if( tmpw <= 0xfafc ) {	tmpw -= 0x0d1c;	}	/* fa9c～fafc → ed80～ede0 (塚～浯) */
			else	if( tmpw <= 0xfb5b ) {	tmpw -= 0x0d5f;	}	/* fb40～fb5b → ede1～edfc (涖～犱) */
			else	if( tmpw <= 0xfb7e ) {	tmpw -= 0x0d1c;	}	/* fb5c～fb7e → ee40～ee62 (犾～神) */
			else	if( tmpw <= 0xfb9b ) {	tmpw -= 0x0d1d;	}	/* fb80～fb9b → ee63～ee7e (祥～蕙) */
			else	if( tmpw <= 0xfbfc ) {	tmpw -= 0x0d1c;	}	/* fb9c～fbfc → ee80～eee0 (蕫～髙) */
			else{							tmpw -= 0x0d5f;	}	/* fc40～fc4b → eee1～eeec (髜～黑) */
		}
		return (unsigned short) _mbcjmstojis( tmpw );
	}
	return 0;
}


/* コード変換 SJIS→JIS */
void CMemory::SJIStoJIS( void )
{
	char*	pBufJIS;
	int		nBufJISLen;
	CMemory	cMem;

	/* SJIS→JIS */
	StrSJIStoJIS( &cMem, (unsigned char *)m_pData, m_nDataLen );
	pBufJIS = cMem.GetPtr( &nBufJISLen );
	SetData( pBufJIS, nBufJISLen );
	return;
}


/*!	SJIS→JIS

	@date 2003.09.07 genta 不要なキャスト除去
*/
int CMemory::StrSJIStoJIS( CMemory* pcmemDes, unsigned char* pszSrc, int nSrcLen )
{
//	BOOL bSJISKAN	= FALSE;
//	BOOL b8BITCODE	= FALSE;

	long			nWorkBgn;
	long			nWorkLen;
	int				i;
	int				j;
	unsigned char *	pszWork;
	int				nCharKindOld;
	int				nCharKind;
	int				bChange;
	nCharKind = CHAR_ASCII;		/* ASCII文字 */
	nCharKindOld = nCharKind;
	bChange = FALSE;
//	/* 文字種別 */
//	#define CHAR_ASCII		0	/* ASCII文字 */
//	#define CHAR_8BITCODE	1	/* 8ビットコード(半角カタカナなど) */
//	#define CHAR_ZENKAKU	2	/* 全角文字 */

	pcmemDes->SetDataSz( "" );
	pcmemDes->AllocBuffer( nSrcLen );
//	bSJISKAN  = FALSE;
	nWorkBgn = 0;
	for( i = 0;; i++ ){
		/* 処理が終了した */
		if( i >= nSrcLen ){
			nCharKind = CHAR_NULL;	/* なにもない */
		}else
		// 漢字か？
		if( ( i < nSrcLen - 1) &&
			/* SJIS全角コードの1バイト目か */	//Sept. 1, 2000 jepro 'シフト'を'S'に変更
			_IS_SJIS_1( pszSrc[i + 0] ) &&
			/* SJIS全角コードの2バイト目か */
			_IS_SJIS_2( pszSrc[i + 1] )
		){
			nCharKind = CHAR_ZENKAKU;	/* 全角文字 */
//			++i;
		}else
		if( pszSrc[i] & (unsigned char)0x80 ){
			nCharKind = CHAR_8BITCODE;	/* 8ビットコード(半角カタカナなど) */
		}else{
			nCharKind = CHAR_ASCII;		/* ASCII文字 */
		}
		/* 文字種類が変化した */
		if( nCharKindOld != nCharKind ){
			if( CHAR_NULL != nCharKind ){
				bChange = TRUE;
			}

			nWorkLen = i - nWorkBgn;
			/* 以前の文字種類 */
			switch( nCharKindOld ){
			case CHAR_ASCII:	/* ASCII文字 */
				if( 0 < nWorkLen ){
					pcmemDes->Append( (char *)&(pszSrc[nWorkBgn]), nWorkLen );
				}
				break;
			case CHAR_8BITCODE:	/* 8ビットコード(半角カタカナなど) */
				if( 0 < nWorkLen ){
					pszWork = new unsigned char[nWorkLen + 1];
					memcpy( pszWork, &pszSrc[nWorkBgn], nWorkLen );
					pszWork[ nWorkLen ] = '\0';
					for( j = 0; j < nWorkLen; ++j ){
						pszWork[j] -= (unsigned char)0x80;
					}
					pcmemDes->Append( (char *)pszWork, nWorkLen );
					delete [] pszWork;
				}
				break;
			case CHAR_ZENKAKU:	/* 全角文字 */
				if( 0 < nWorkLen ){
					pszWork = new unsigned char[nWorkLen + 1];
					memcpy( pszWork, &pszSrc[nWorkBgn], nWorkLen );
					pszWork[ nWorkLen ] = '\0';
					// SJIS→JIS変換
					nWorkLen = MemSJIStoJIS( pszWork, nWorkLen );
					pcmemDes->Append( (char *)pszWork, nWorkLen );
					delete [] pszWork;
				}
				break;
			}
			/* 新しい文字種類 */
			switch( nCharKind ){
			case CHAR_ASCII:	/* ASCII文字 */
				pcmemDes->AppendSz( ESC_ASCII );
				break;
			case CHAR_NULL:		/* なにもない */
				if( bChange &&					/* 一回は文字種が変化した */
					nCharKindOld != CHAR_ASCII	/* 直前がASCII文字ではない */
				){
					pcmemDes->AppendSz( ESC_ASCII );
				}
				break;
			case CHAR_8BITCODE:	/* 8ビットコード(半角カタカナなど) */
				pcmemDes->AppendSz( ESC_8BIT );
				break;
			case CHAR_ZENKAKU:	/* 全角文字 */
				pcmemDes->AppendSz( ESC_JIS );
				break;
			}
			nCharKindOld = nCharKind;
			nWorkBgn = i;
			if( nCharKind == CHAR_NULL ){	/* なにもない */
				break;
			}
		}
		if( nCharKind == CHAR_ZENKAKU ){	/* 全角文字 */
			++i;
		}
	}
	return pcmemDes->m_nDataLen;
}



/* SJIS→JIS変換 */
long CMemory::MemSJIStoJIS( unsigned char* pszSrc, long nSrcLen )
{
	int				i, j;
	char *			pszDes;
	unsigned short	sCode;

	pszDes = new char[nSrcLen + 1];
	memset( pszDes, 0, nSrcLen + 1 );
	j = 0;
	for( i = 0; i < nSrcLen - 1; i++ ){
		//	Oct. 3, 2002 genta IBM拡張文字対応
		sCode = _mbcjmstojis_ex( pszSrc + i );
		if( sCode != 0 ){
			pszDes[j	] = (unsigned char)(sCode >> 8);
			pszDes[j + 1] = (unsigned char)(sCode);
			++i;
			j += 2;
		}else{
			pszDes[j] = pszSrc[i];
			j++;
		}
12 3 4 5 下一页
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -