• 로그인 함 해보끄나?

  • Sarangnamu.net June 17, 2003
    Home Login Profile Study Open Project Q&A Google Code
    CStringConvert 7bit alphabet
    Last Modify : 27 December, 2010(02:27)
    // DATE		: April 6, 2007
    // CODER	: Kurome (aucd29@gmail.com)
    //
    //
    //
    // --------------------------------------------------------
    // NOTE : April 09, 2007
    // --------------------------------------------------------
    // * 7BIT UNICODE -> 7BIT ASCII -> UCS2 변경
    //
    
    #include "StdAfx.h"
    #include "StringConvert.h"
    
    // --------------------------------------------------------
    // 7Bit Ascii Table 
    // --+---+---+----+----+---+---+---+---+---+---+---+---+---
    //   |   |   |    | B7 | 0 | 0 | 0 | 0 | 1 | 1 | 1 | 1 |   
    //   |   |   |    | B6 | 0 | 0 | 1 | 1 | 0 | 0 | 1 | 1 |   
    //   |   |   |    | B5 | 0 | 1 | 0 | 1 | 0 | 1 | 0 | 1 |  
    // --+---+---+----+----+---+---+---+---+---+---+---+---+
    // B4| B3| B2| B1 |    | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
    // --+---+---+----+----+---+---+---+---+---+---+---+---+
    // 0 | 0 | 0 | 0  | 0  | @ | Δ| SP| 0 | - | P |   |   |
    // --+---+---+----+----+---+---+---+---+---+---+---+---+
    // 0 | 0 | 0 | 1  | 1  |   |   | ! | 1 | A | Q | a | p |
    // --+---+---+----+----+---+---+---+---+---+---+---+---+
    // 0 | 0 | 1 | 0  | 2  | $ | Φ| " | 2 | B | R | b | q |
    // --+---+---+----+----+---+---+---+---+---+---+---+---+
    // 0 | 0 | 1 | 1  | 3  |   | Γ| # | 3 | C | S | c | r |
    // --+---+---+----+----+---+---+---+---+---+---+---+---+
    // 0 | 1 | 0 | 0  | 4  |   | Λ|   | 4 | D | T | d | s |
    // --+---+---+----+----+---+---+---+---+---+---+---+---+
    // 0 | 1 | 0 | 1  | 5  |   | Ω| % | 5 | E | U | e | t |
    // --+---+---+----+----+---+---+---+---+---+---+---+---+
    // 0 | 1 | 1 | 0  | 6  |   | Π| & | 6 | F | V | f | u |
    // --+---+---+----+----+---+---+---+---+---+---+---+---+
    // 0 | 1 | 1 | 1  | 7  |   | Ψ| ' | 7 | G | W | g | v |
    // --+---+---+----+----+---+---+---+---+---+---+---+---+
    // 1 | 0 | 0 | 0  | 8  |   | Σ| ( | 8 | H | X | h | w |
    // --+---+---+----+----+---+---+---+---+---+---+---+---+
    // 1 | 0 | 0 | 1  | 9  |   | Θ| ) | 9 | I | Y | i | x |
    // --+---+---+----+----+---+---+---+---+---+---+---+---+
    // 1 | 0 | 1 | 0  | 10 | LF| Ξ| * | : | J | Z | j | y |
    // --+---+---+----+----+---+---+---+---+---+---+---+---+
    // 1 | 0 | 1 | 1  | 11 |   |   | + | ; | K |   | k | z |
    // --+---+---+----+----+---+---+---+---+---+---+---+---+
    // 1 | 1 | 0 | 0  | 12 |   |   | , | < | L |   | l |   |
    // --+---+---+----+----+---+---+---+---+---+---+---+---+
    // 1 | 1 | 0 | 1  | 13 | CR|   | - | = | M |   | m |   |
    // --+---+---+----+----+---+---+---+---+---+---+---+---+
    // 1 | 1 | 1 | 0  | 14 |   | β| . | > | N |   | n |   |
    // --+---+---+----+----+---+---+---+---+---+---+---+---+
    // 1 | 1 | 1 | 1  | 15 |   |   | / | ? | O |   | o |   |
    // --+---+---+----+----+---+---+---+---+---+---+---+---+
    //
    
    
    CStringConvert::CStringConvert(void)
    : m_bChanged(false)
    {
    	m_mapBinaryTable[L'0'] = 0x00;
    	m_mapBinaryTable[L'1'] = 0x01;
    	m_mapBinaryTable[L'2'] = 0x02;
    	m_mapBinaryTable[L'3'] = 0x03;
    	m_mapBinaryTable[L'4'] = 0x04;
    	m_mapBinaryTable[L'5'] = 0x05;
    	m_mapBinaryTable[L'6'] = 0x06;
    	m_mapBinaryTable[L'7'] = 0x07;
    	m_mapBinaryTable[L'8'] = 0x08;
    	m_mapBinaryTable[L'9'] = 0x09;
    	m_mapBinaryTable[L'A'] = 0x0A;
    	m_mapBinaryTable[L'B'] = 0x0B;
    	m_mapBinaryTable[L'C'] = 0x0C;
    	m_mapBinaryTable[L'D'] = 0x0D;
    	m_mapBinaryTable[L'E'] = 0x0E;
    	m_mapBinaryTable[L'F'] = 0x0F;
    
    	// 특수문자는 유니코드변환시 약간 번호가 다르니깐
    	// 따로 값을 주고 나머진 바로 변환 가능하다.
    	m_map7bitToUnicode[0x00] = L'@';
    	m_map7bitToUnicode[0x02] = L'$';
    	m_map7bitToUnicode[0x10] = L'Δ';
    	m_map7bitToUnicode[0x12] = L'Φ';
    	m_map7bitToUnicode[0x13] = L'Γ';
    	m_map7bitToUnicode[0x14] = L'Λ';
    	m_map7bitToUnicode[0x15] = L'Ω';
    	m_map7bitToUnicode[0x16] = L'Π';
    	m_map7bitToUnicode[0x17] = L'Ψ';
    	m_map7bitToUnicode[0x18] = L'Σ';
    	m_map7bitToUnicode[0x19] = L'Θ';
    	m_map7bitToUnicode[0x1A] = L'Ξ';
    	m_map7bitToUnicode[0x1E] = L'β';
    }
    
    CStringConvert::CStringConvert(CString szData)
    : m_szText(szData)
    {
    	
    }
    
    CStringConvert::~CStringConvert(void)
    {
    
    }
    
    void CStringConvert::Trace(void)
    {
    	TRACE(L"-----------------------------------------------------\n");
    	TRACE(L"| CStringConvert									|\n");
    	TRACE(L"-----------------------------------------------------\n");
    	TRACE(m_szText + L"\n");
    	TRACE(L"-----------------------------------------------------\n");
    }
    
    // Operator -----------------------------------------------------
    
    void CStringConvert::operator = (CString szData)
    {
    	m_szText = szData;
    }
    
    CString CStringConvert::PC2SerialUnicode(void)
    {
    	// serial로 보낼 unicode형식에 string을 만들자.
    	//
    	CString szTemp = m_szText;
    	wchar_t* pStr  = const_cast<wchar_t*>(static_cast<LPCTSTR>(szTemp));
    	wchar_t wString[5] = {0};
    	m_szText = L"";
    	
    	while (*pStr)
    	{
    		wsprintf(wString, L"%04x", *pStr);
    		m_szText += wString;
    		pStr++;
    	}
    
    	return m_szText;
    }
    
    CString CStringConvert::PC2Serial7Bit(void)
    {
    	// serial로 보낼 7bit 형식에 string을 만든다.
    	//
    	wchar_t* pStr = const_cast<wchar_t*>(static_cast<LPCTSTR>(m_szText));
    	int nLength	  = m_szText.GetLength();
    	int nIndex	  = 0;
    	m_strText     = new unsigned char[nLength + 1];
    	memset(m_strText, 0, nLength + 1);
    
    	// 8bit style로 구성
    	while (nLength--)
    	{
    		m_strText[nIndex] = IsSpecialCharacter(pStr);
    
    		if (!m_bChanged)
    		{
    			m_strText[nIndex] = static_cast<char>(*pStr);
    		}
    
    		m_bChanged = false;
    		++pStr;
    		++nIndex;
    	}
    
    	// 7bit style로 구성
    	list<unsigned char> m_listTemp;
    	unsigned char cTemp = 0;
    	unsigned char* pPrePosition;
    	unsigned char* pThisPosition;
    	int nShift = 0;
    	
    	nLength = m_szText.GetLength() + 1;
    	pPrePosition = pThisPosition = m_strText;
    	
    	while (nLength--)
    	{		
    		cTemp			  = *pThisPosition;
    		*pThisPosition  >>= nShift;
    		cTemp		    <<= (8 - nShift);
    		*pPrePosition    |= cTemp;
    
    		if (++nShift == 8)
    		{
    			nShift = 0;
    		}
    
    		pPrePosition = pThisPosition;
    		pThisPosition++;
    	}
    
    	nLength		  = m_szText.GetLength();
    	pThisPosition = m_strText;
    	CString szFormat;
    	m_szText = L"";
    	while (nLength--)
    	{
    		// 0 값은 제외 시키기 위해서
    		if (*pThisPosition)
    		{
    			szFormat.Format(L"%02x", *pThisPosition);
    			m_szText += szFormat;
    		}
    		pThisPosition++;
    	}
    
    	delete m_strText;
    	return m_szText;
    }
    
    CString CStringConvert::Serial2PCUnicode(void)
    {
    	// serial로 받은 unicode 형식(0045) 에 string을 
    	// 문자로 바꾸자
    	//
    	int nLen   = m_szText.GetLength();
    	int nWord  = nLen / 4;
    	int nFirst = 0, i = 0;
    	long N;
    	wchar_t szDumy[7] = {0};
    
    	m_wstrText = new wchar_t[nWord + 1];
    	memset(m_wstrText, 0, sizeof(wchar_t) * (nWord + 1));
    	do 
    	{
    		wsprintf(szDumy, L"0x%s", m_szText.Mid(nFirst, 4));
    		swscanf_s(szDumy, L"%x", &N);
    		wsprintf(&m_wstrText[i++], L"%c", N);
    		memset(szDumy, 0, sizeof(wchar_t) * 7);
    
    		nFirst += 4;
    	}
    	while(--nWord);
    	m_wstrText[i] = 0;
    	m_szText.Format(L"%s", m_wstrText);
    	delete m_wstrText;
    
    	return m_szText;
    }
    
    CString CStringConvert::Serial2PC7Bit(void)
    {
    	// serial로 받은 7bit 문자를 일반 문자로
    	// 바꾸자.
    
    	// E8 : 11101000
    	// 32 : 00110010
    	// 9B : 10011011
    	// FD : 11111101
    	// 46 : 01000110
    	// 97 : 10010111
    	// D9 : 11011001
    	// EC : 11101100
    	// 37 : 110111
    
    	// 1 1101000			7
    	// 00 110010			6
    	// 100 11011			5
    	// 1111 1101			4
    	// 01000 110			5
    	// 100101 11			2
    	// 1101100 1100101		1
    	// 1 1101100
    	// 11 0111
    
    	// H 1101000
    	// E 1100101
    	// L 1101100
    	// L 1101100
    	// O 1101111
    	// H 1101000
    	// E 1100101
    	// L 1101100
    	// L 1101100
    	// O 1101111
    
    	// MFC에서는 좀 특수한 상황이라 -_ -;;
    	// 영 ㅈㄹ같군...
    	// 우선은 UNICODE 로 들어온 7BIT GSM 코드를
    	// ASCII 로 변경하고 이후에 8BIT ASCII로 변경하고
    	// 8BIT ASCII를 다시 -_ - UNICODE로 변경해야된다.. 
    	// 한마디로... 미치겠다 -_-
    
    	// wchar_t 로 type casting 했으니 이제 손쉽게 jump
    	int nStrLength  = (m_szText.GetLength() / 2) + 1;	// terminate를 위해 + 1
    	bool bFirst		= true;
    	wchar_t* pPos   = const_cast<wchar_t*>(static_cast<LPCTSTR>(m_szText));		
    	unsigned char* p7bitCode = new unsigned char[nStrLength];
    	unsigned char* pJump = p7bitCode;
    	memset(p7bitCode, 0, nStrLength);
    
    	while(*pPos)
    	{
    		if (bFirst)
    		{
    			// left shift 4bit
    			//TRACE(L"INDEX CODE :%c ", *pPos);
    			//TRACE(L"RETURN VALUE : %x ", m_mapBinaryTable[*pPos]);
    			*pJump = m_mapBinaryTable[*pPos] << 4;
    			//TRACE(L"VALUE : %x\n", *pJump);
    		}
    		else
    		{	
    			//TRACE(L"INDEX CODE :%c ", *pPos);
    			//TRACE(L"RETURN VALUE : %x ", m_mapBinaryTable[*pPos]);
    			*pJump |= m_mapBinaryTable[*pPos];
    			//TRACE(L"VALUE : %x\n", *pJump);
    			pJump++;
    		}
    		pPos++;
    		bFirst = !bFirst;
    	}
    	*pJump = 0;
    
    	// 자 여기까지 7bit ascii 코드 완성
    	// 이제부턴 8bit ascii 코드를 맹글어야 하는데 말이지...
    
    	// jump code를 초기화 시키고
    	pJump = p7bitCode;
    	unsigned char pTemp = 0, pTemp2 = 0;
    	int nShift = 7;
    	list<unsigned char> listTempCharacter;
    	while (*pJump)
    	{
    		// copy data
    		//pTemp  = *pJump;						// E8 : 1110 1000, 32 : 0011 0010
    		pTemp    = *pJump >> nShift;			// E8 : 0000 0001, 32 : 0000 0000
    		*pJump <<= (8 - nShift);				// E8 : 1101 0000, 32 : 1100 1000
    		*pJump >>= 1;							// E8 : 0110 1000, 32 : 0011 0010
    		*pJump  |= pTemp2;						//      0110 1000, 32 : 0011 0011
    		
    		listTempCharacter.push_back(*pJump);
    		pJump++;
    		
    		if (--nShift == 0)
    		{
    			nShift = 7;
    			listTempCharacter.push_back(pTemp);
    			pTemp2 = 0;
    		}
    		else
    		{
    			pTemp2 = pTemp;						// E8 : 0000 0001
    		}
    	}	
    	delete p7bitCode;
    
    	list<unsigned char>::iterator it;
    	nStrLength = static_cast<int>(listTempCharacter.size());
    	it		   = listTempCharacter.begin();
    
    	wchar_t wTemp;
    	while (nStrLength--)
    	{
    		// 해당 테이블에 값이 있으면 그 값을 넣어주고
    		// 없다면 casting 한다.
    		if (wTemp = m_map7bitToUnicode[*it])
    		{
    			m_szText.AppendChar(wTemp);
    		}
    		else
    		{
    			m_szText.AppendChar(static_cast<wchar_t>(*it));
    		}
    
    		it++;
    	}
    
    	return m_szText;
    }
    
    void CStringConvert::UniToChar(char* pStr, int nLen)
    {
    	memset(pStr, 0, nLen);
    	WideCharToMultiByte(CP_ACP, 0, m_szText, -1, pStr, nLen, NULL, NULL);
    }
    
    void CStringConvert::CharToUni(char* szSrc)
    {
    	int nLen = static_cast<int>(strlen(szSrc));
    	wchar_t* m_wstrText = new wchar_t[nLen];
    
    	memset(m_wstrText, 0, sizeof(wchar_t) * nLen);
    	MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szSrc, nLen, m_wstrText, nLen);
    	m_szText.Format(L"%s", szSrc);
    
    	delete m_wstrText;
    }
    
    unsigned char CStringConvert::IsSpecialCharacter(wchar_t* pwCharacter)
    {
    	map<unsigned char, wchar_t>::iterator it = m_map7bitToUnicode.begin();
    	int nLength = static_cast<int>(m_map7bitToUnicode.size());
    
    	while (nLength--)
    	{
    		if (it->second == *pwCharacter)
    		{
    			m_bChanged = true;
    			return it->first;
    		}
    
    		it++;
    	}
    
    	return false;
    }
    
    #pragma once
    
    #include <map>
    #include <list>
    using namespace std;
    
    class CStringConvert
    {
    protected:
    	CString m_szText;
    	unsigned char* m_strText;
    	wchar_t* m_wstrText;
    	bool m_bStr, m_bWstr, m_bChanged;
    
    	// 다소 부하가 있지만... 그렇다고
    	// 더 나은 방법이 있는것도 아닌것이..
    	map<wchar_t, unsigned char> m_mapBinaryTable;
    	map<unsigned char, wchar_t> m_map7bitToUnicode;		// 어차피 난 출력은 unicode를 써야잖아.
    
    public:
    	CStringConvert(void);
    	CStringConvert(CString szData);
    	~CStringConvert(void);
    	void Trace(void);
    
    	// operator
    	void operator = (CString szData);
    
    	CString PC2SerialUnicode(void);
    	CString PC2Serial7Bit(void);
    	CString Serial2PCUnicode(void);
    	CString Serial2PC7Bit(void);
    	void UniToChar(char* pStr, int nLen);
    	void CharToUni(char* szSrc);
    	unsigned char IsSpecialCharacter(wchar_t* pwCharacter);
    };
    

    Comment


    입력하3 1502977337



    Locations of visitors to this page