词法分析

开发平台：
Visual C++

Inputer.h：源码内容
							
//
//	Inputer.h
//		汉字输入法
//	Author	:	zhanlc
//	Date	:	2003/9/5
//
#ifndef	__ChineseInputer_H__
#define	__ChineseInputer_H__
#include	<list>
#include	<vector>
#include	<map>
#include	<algorithm>
using	namespace	std;
namespace	Chinese 
{
/**
*	字
*/
class	Word
{
public :
	/**
	*	构造函数
	*/
	Word() 
	{
		Init( TCHAR(''), TCHAR('') );
	};
		
	/**
	*	根据字符串初始化
	*/
	Word( const TCHAR* szWord ) 
	{
		Init( szWord[0], szWord[1] );
	}
		
	/**
	*	根据字符串初始化
	*/
	Word( const CString& strWord ) 
	{
		Init( strWord [0], strWord [1] );
	}
		
	/**
	*	根据字节直接初始化
	*/	
	Word( TCHAR cLow, TCHAR cHigh ) 
	{
		Init( cLow, cHigh );
	};
		
	/**
	*	转换成字符串	
	*/
	operator CString() 
	{
		CString	strWord( TCHAR(''), 3 );
		strWord.SetAt( 0, m_Word[0] );
		strWord.SetAt( 1, m_Word[1] );
		
		return	strWord;
	}
		
	/**
	*	判断是否和字符串相等
	*/
	BOOL	operator==( const TCHAR* szWord ) const
	{
		return	szWord[0] == m_Word[0] && szWord[1] == m_Word[1];
	}
		
	/**
	*	判断是否和字符串相等
	*/ 
	BOOL	operator==( const CString&	szWord ) const
	{
		return	szWord[0] == m_Word[0] && szWord[1] == m_Word[1];
	}
		
	/**
	*	判断是否相等
	*/
	BOOL	operator==( const Word& wd ) const
	{
		return	wd.m_Word[0] == m_Word[0] && wd.m_Word[1] == m_Word[1];
	}
	/**
	*	比较运算符
	*/
	BOOL	operator<( const Word& wd ) const
	{
		//return	m_Word[1] < wd.m_Word[1]  &&  m_Word[0] < wd.m_Word[0];
		return	*( (unsigned short*)&m_Word[0]) < *( (unsigned short*)&wd.m_Word[0]);
	}
		
	/**
	*	获得低字节
	*/
	TCHAR	GetLow() const
	{
		return	m_Word[0];
	}
		
	/**
	*	获得高字节
	*/
	TCHAR	GetHigh() const
	{
		return	m_Word[1];
	}
// I/O
public :
	/**
	*	保存到文件流
	*/
	template	<class	TStream>
	void	operator >> ( TStream& os ) const
	{
		os	<< m_Word[0] << m_Word[1];
	};
	/**
	*	从流中读入
	*/
	template	<class	TStream>
	void	operator<<( TStream& os )
	{
		os	>> m_Word[0]	>> m_Word[1] ;
	}
	
protected :
	/**
	*	初始化
	*/
	void	Init( TCHAR cLow, TCHAR cHigh )
	{
		m_Word[0]	=	cLow;
		m_Word[1]	=	cHigh;
	};
		
protected :
	/**
	*	汉字	
	*/
	TCHAR		m_Word[2];
};
/**
*	笔顺类
*		"12345"	---	"一丨丿丶乙"  
*/
class	StrokesOrder
{
public :
	/**
	*	构造函数
	*/
	StrokesOrder( const TCHAR* sz=_T(""));
	/**
	*	将笔顺转换成数字字符形式
	*/
	const CString&		GetAsDigits() const
	{
		return	m_DigitStroks;
	};
	/**
	*	重载字符转换, 数字字符形式
	*/
	operator const CString&()	const
	{
		return	m_DigitStroks;
	};
	
	/**
	*	将笔顺转换成笔画形式
	*/
	CString		GetAsStroks() const;
	/**
	*	获得笔画长度
	*/
	int			GetLength() const
	{
		return	m_DigitStroks.GetLength();
	};
	/**
	*	比较操作符
	*/
	BOOL	operator==( const StrokesOrder& odr ) const
	{
		return	m_DigitStroks	==	odr.m_DigitStroks;
	}
	/**
	*	比较操作符
	*/
	BOOL	operator==( const TCHAR* szOdr ) const
	{
		return	operator==( StrokesOrder(szOdr) );
	}
	/**
	*	比较操作符
	*/
	BOOL	operator==( const CString& szOdr ) const
	{
		return	operator==( StrokesOrder(szOdr) );
	}
	/**
	*	设置笔顺
	*/
	BOOL	Set( const TCHAR* szStrokesOrder );
	/**
	*	赋值函数
	*/
	BOOL	operator=( const TCHAR* szStrokesOrder )
	{
		return	Set( szStrokesOrder );
	}
public	:
	/**
	*	横
	*/
	static	Word	s_Heng;
	/**
	*	竖
	*/
	static	Word	s_Shu;
	/**
	*	撇
	*/
	static	Word	s_Pie;
	/**
	*	捺
	*/
	static	Word	s_Na;
	/**
	*	折
	*/
	static	Word	s_Zhe;
	/**
	*	横
	*/
	static	TCHAR	s_cHeng;
	/**
	*	竖
	*/
	static	TCHAR	s_cShu;
	/**
	*	撇
	*/
	static	TCHAR	s_cPie;
	/**
	*	捺
	*/
	static	TCHAR	s_cNa;
	/**
	*	折
	*/
	static	TCHAR	s_cZhe;
protected :
	/**
	*	以数字形式表示得笔顺
	*/		
	CString		m_DigitStroks;
};
/**
*	拼音组， 用于将多个拼音组合一个字符串拼音，可以用于多音字
*/
class	SpellGroup
{
public :
	typedef		/*list*/vector<CString>				StringList;
	typedef		StringList::const_iterator	const_iterator;
	typedef		StringList::iterator		iterator;
	
	/**
	*	构造函数
	*/
	SpellGroup();
	/**
	*	构造函数
	*/
	SpellGroup( const TCHAR* szGroup );
	
	/**
	*	获得拼音个数
	*/
	int		GetCount() const;
	/**
	*	获得第i个拼音
	*/
	const CString&	operator[]( int i );
	/**
	*	将所有拼音转换成一个字符串
	*/
	CString	GetAsString() const;
	/**
	*	操作符重载
	*/
	operator CString() const;
	/**
	*	加入拼音
	*/
	void	Add( const TCHAR* szSpell );
	/**
	*	加入组
	*/
	void	AddGroup( const TCHAR* szSpell );
	/**
	*	删除拼音
	*/
	void	Remove( const TCHAR* szSpell );
	/**
	*	删除所有拼音
	*/
	void	RemoveAll();
	/**
	*	开始迭代器
	*/
	iterator	begin() 
	{
		return	m_vSpell.begin();
	}
	/**
	*	开始迭代器
	*/
	iterator	end() 
	{
		return	m_vSpell.end();
	}
	/**
	*	开始迭代器
	*/
	const_iterator	begin() const
	{
		return	m_vSpell.begin();
	}
	/**
	*	开始迭代器
	*/
	const_iterator	end() const
	{
		return	m_vSpell.end();
	}
	/**
	*	包含某个注音
	*/
	BOOL	HaveSpell( const TCHAR* szSpell ) const
	{
		return	find( m_vSpell.begin(), m_vSpell.end(), szSpell) != m_vSpell.end();
	}
	/**
	*	将多个拼音组相加
	*/
	static	CString		Add( const CString& strOne, const CString& strTwo )
	{
		CString		strNew;
		if ( strOne == _T("") )
		{
			strNew = strTwo;
		}
		else
		{
			strNew	=	strOne;
			if ( strTwo != _T("") )
				strNew	+=	_T(":") + strTwo;
		}
		return	strNew;
	}
// I/O
public :
	/**
	*	保存到文件流
	*/
	template	<class	TStream>
	void	operator >> ( TStream& os ) const
	{
		int	nLen	=	m_vSpell.size();
		os	<< nLen;
		for ( int i=0; i<nLen; i++ )
			os << m_vSpell[i];
	};
	/**
	*	从流中读入
	*/
	template	<class	TStream>
	void	operator<<( TStream& os )
	{
		int	nLen;
		os >> nLen ;
		/*
		ASSERT( nLen > 0 );
		m_vSpell.resize(nLen);
		for ( int i=0; i<nLen; i++ )
			os >> m_vSpell[i];
		*/
		if ( nLen > 0 )
		{
			m_vSpell.resize(nLen);
			
			for ( int i=0; i<nLen; i++ )
				os >> m_vSpell[i];
		}
		else
			m_vSpell.clear();
	}
	
protected :
	/**
	*	拼音集合
	*/
	StringList	m_vSpell;
};
/**
*	中文字典
*/
class	ChineseDictionary
{
public :
	/**
	*	部首
	*/
	class	BSWord	:	public Word
	{
	public :
		BSWord()	{}
		/**
		*	根据字符串初始化
		*/
		BSWord( const TCHAR* szWord, 
			    int nStrokes, 
				const TCHAR* szDscr )  : Word(szWord)
		{
		}
		
		/**
		*	根据字符串初始化
		*/
		BSWord( const CString& strWord,
				int nStrokes, 
				const TCHAR* szDscr) : Word(strWord)
		{
		}
		
		/**
		*	根据字节直接初始化
		*/	
		BSWord( TCHAR cLow, TCHAR cHigh,
				int nStrokes, 
				const TCHAR* szDscr ) : Word(cLow, cHigh )
		{
		};
		/**
		*	获得描述
		*/
		const	CString&	GetDescrib() const
		{
			return	m_strDscr;
		}
		/**
		*	获得笔画
		*/
		int		GetStrokes( ) const
		{
			return	m_nStrokes;
		}
	protected :
		/**
		*	初始化	
		*/
		BOOL	Init( int nStrokes, const TCHAR* szDscr )
		{
			m_nStrokes	=	nStrokes;
			m_strDscr	=	szDscr;
			return	TRUE;
		}
	protected :
		/**
		*	描述
		*/
		CString		m_strDscr;
		/**
		*	笔画
		*/
		int			m_nStrokes;
	};
	/**
	*	部首容器
	*/
	class	BSWords
	{
	public :
		/**
		*	部首枚举器
		*/
		typedef		const	BSWord*		iterator;
		/**
		*	获得起始部首
		*/
		iterator	begin() const;
		/**
		*	结束
		*/
		iterator	end() const;
			
		/**
		*	部首数目
		*/
		int			size() const;
	};
	/**
	*	字解释
	*/
	class	WordComment
	{
		friend	class	ChineseDictionary;
	public :
		/**
		*	构造函数
		*/
		WordComment() /*: m_strSpell(_T(""))*/ {};
		/**
		*	构造函数
		*/
		WordComment( Word wBS, unsigned short nStrokes, 
					 const SpellGroup& sgSpell, 
					 const StrokesOrder& sOrder )  : 
			m_BS(wBS), m_nStroks(nStrokes), m_StroksOrder(sOrder),
			m_SpellGroup(sgSpell)
		{
				//m_strSpell	=	sgSpell.GetAsString();
		};
		/**
		*	获得笔画数
		*/
		int		GetStrokes() const
		{
			return	m_nStroks;
		};
		/**
		*	设置笔画数
		*/
		void	SetStrokes( unsigned short nStrokes ) 
		{
			m_nStroks	=	nStrokes;
		};
		/**
		*	获得部首
		*/
		Word	GetBS() const
		{
			return	m_BS;
		};
		/**
		*	设置部首
		*/
		void	SetBS( Word wdBS ) 
		{
			m_BS	=	wdBS;
		};
		/**
		*	获得笔顺
		*/
		const	StrokesOrder& GetStrokesOrder() const
		{
			return m_StroksOrder;
		};
		/**
		*	设置笔顺
		*/
		void	SetStrokesOrder( const StrokesOrder& sodr ) 
		{
			m_StroksOrder	=	sodr;
		};
		/**
		*	获得拼音组
		*/
		const SpellGroup&	GetSpellGroup( ) const
		{
			return	m_SpellGroup;//SpellGroup(m_strSpell);
		}
		/**
		*	设置新的拼音组
		*/
		void	SetSpellGroup( const SpellGroup& sg )
		{
			//m_strSpell	=	sg.GetAsString( );
			m_SpellGroup	=	sg;
		}
		/**
		*	判断是否有某个注音
		*/
		BOOL		HaveSpell( const TCHAR* szSpell ) const
		{
			return	/*SpellGroup(m_strSpell).*/m_SpellGroup.HaveSpell(szSpell);
		}
	// I/O 
	public :
		/**
		*	保存到文件流
		*/
		template	<class	TStream>
		void	operator >> ( TStream& os ) const
		{
			// 部首
			m_BS	>>	os;
			os << m_nStroks;
			//os << /*m_strSpell*/m_SpellGroup << m_StroksOrder.GetAsDigits();
			m_SpellGroup >> os;
			os << m_StroksOrder.GetAsDigits( );
		}
		/**
		*	从流中读入
		*/
		template	<class	TStream>
		void	operator<< ( TStream& os )
		{
			// 部首
			m_BS	<<	os;
			CString	strStrokesOrder;
			os >> m_nStroks;
			//os >> /*m_strSpell*/m_SpellGroup >> strStrokesOrder;
			m_SpellGroup << os;
			os >> strStrokesOrder;
			m_StroksOrder = strStrokesOrder;
		}
	protected :
		/**
		*	部首
		*/
		Word	m_BS;
		/**
		*	笔画数
		*/
		unsigned short	m_nStroks;
		/**
		*	拼音, 多音字用:分割
		*/
		//CString	m_strSpell;
		SpellGroup	m_SpellGroup;
		/**
		*	笔顺
		*/
		StrokesOrder	m_StroksOrder;
	};
	/**
	*	字典条目
	*/
	class	WordItem
	{
		friend	class	ChineseDictionary;
		/**
		*	构造函数
		*/
		WordItem( Word wd, const WordComment* wdcm )  
			: m_Word(wd), m_pComment(wdcm)
		{
		};
	public :
		/**
		*	构造函数
		*/
		WordItem() : m_Word( TCHAR('0'), TCHAR('0') ), m_pComment(NULL)
		{
		};
		/**
		*	获得字
		*/
		Word	GetWord() const
		{
			return	m_Word;
		}
		/**
		*	获得字注解
		*/
		const	WordComment&	GetComment() const
		{
			ASSERT( m_pComment );
			return	*m_pComment;
		}
		/**
		*	比较运算
		*/
		BOOL	operator==( const WordItem& witm ) const
		{
			return	m_Word == witm.m_Word && 
					m_pComment == witm.m_pComment;
		}
		/**
		*		比较运算
		*/
		BOOL	operator!=( const WordItem& witm ) const
		{
			return	!operator==( witm );
		}
		/**
		*	判断是否是合法的词条
		*/
		operator BOOL() const;
	protected :
		/**
		*	字
		*/
		Word		   m_Word;
		/**
		*	字注解
		*/
		const WordComment*    m_pComment;	
	}; // end of word item
	/**
	*	定义字典条目得引用
	*/
	typedef	const	WordItem	WordItemRef;
	/**
	*	非法词条
	*/
	static	WordItem	NullWordItemRef;
	/**
	*	查某个字的解释
	*/
	static	WordItemRef		Get( Word wdLookup );
	/**
	*	加入词条
	*/
	static	void			AddWord( Word wd, const WordComment& wdcm );
	/**
	*	清空所有词条
	*/
	static	void		Clear(  );
	/**
	*	从文件中装入字典
	*/
	static	BOOL	Load( const TCHAR* szFile );
	/**
	*	将字典保存到文件中
	*/
	static	BOOL		Save( const TCHAR* szFile );
//=======================================================================================
//
//	查询器
//
//=======================================================================================
public :
	/**
	*	汉字枚举器
	*/
	typedef		list<Word>	WordEnumerator;
	/**
	*	汉字表
	*/
	typedef	map<Word, WordComment>	WordTable;
	/**
	*	查询器基类
	*/
	class	QueryBase
	{
	protected :
		/**
		*	初始化查询器
		*/
		virtual	BOOL	Initialize( WordTable* pWordTable);
		/**
		*	销毁
		*/
		virtual	void	Uninitialize( );
	protected :
		/**
		*	汉字表
		*/
		WordTable*	m_pWordTbl;
	};
	/**
	*	部首查询器
	*/
	class	BSQuery : public QueryBase
	{
		friend	class	ChineseDictionary;
	public :
		/**
		*	根据输入部首， 查询汉字
		*/
		BOOL	QueryWords( const TCHAR* szBuShou, WordEnumerator& enumer );
	};
	/**
	*	笔画查询器
	*/
	class	StrokesQuery : public QueryBase
	{
		friend	class	ChineseDictionary;
	public :
		/**
		*	根据输入笔画， 查询汉字
		*/
		BOOL	QueryWords( int nStroks, WordEnumerator& enumer );
		/**
		*	根据输入笔画， 查询汉字
		*/
		BOOL	QueryWords( const TCHAR* szStrokes, WordEnumerator& enumer );
	};
	/**
	*	字符索引基类
	*/
	class	StringQueryBase	:	public	QueryBase
	{
	protected :
		//typedef		vector<Word>			Words;
		typedef		list<Word>			Words;
		typedef		map<CString, Words>		String2Words;
	public :  //!by zqp edit 205.06.17  protected edit public
 		/*
		*	初始化查询器
		*/
		BOOL	Initialize( WordTable* pWordTable);
		/**
		*	销毁
		*/
		void	Uninitialize( );
		/**
		*	初始化字条目
		*/
		virtual	void	InitWord( Word wd, const WordComment& wc ) { };
		/**
		*	访问迭代器
		*/
		class	iterator : public String2Words::iterator
		{
			typedef		String2Words::iterator	base_class;
		public :
			iterator( base_class it )  : base_class (it) 
			{
			}
			/**
			*	重载指针操作
			*/
			Words&	operator*( )
			{
				base_class&	it	=	*this;
				Words&	words	=	it->second;
				return	words;
			}
		}; 
		/**
		*	返回起始迭代位置
		*/
		iterator	begin( )
		{
			return	iterator( m_String2Words.begin() );
		}
		iterator	end()
		{
			return	iterator( m_String2Words.end() );
		}
		
	protected :
		/**
		*	加入字符到字得映射
		*/
		void	AddMap( const TCHAR* szString, Word wd );
		/**
		*	获得映射表
		*/
		String2Words&	GetMapTable( );
	public :
		/**
		*	根据字符串查询	
		*/
		BOOL	QueryWords( const TCHAR* szSpell, WordEnumerator& enumer );
	protected :
		
		/**
		*	字符串到字得映射
		*/
		String2Words		m_String2Words;
	};
	/**
	*	拼音查询器
	*/
	class	SpellQuery  : public StringQueryBase//QueryBase
	{
		friend	class	ChineseDictionary;
	
	protected :
		/*
		*	初始化查询器
		*/
		BOOL	Initialize( WordTable* pWordTable);
		/**
		*	初始化字
		*/
		void	InitWord( Word wd, const WordComment& wc );
	};
	/**
	*	笔顺查询器
	*/
	class	StrokesOrderQuery	:	public SpellQuery
	{
		friend	class	ChineseDictionary;
	protected :
		/**
		*	初始化字
		*/
		void	InitWord( Word wd, const WordComment& wc );
	};
public :
	/**
	*	获的部首查询器
	*/
	static	BSQuery*	GetBSQuery();
	/**
	*	获的笔画查询器
	*/
	static	StrokesQuery*	GetStrokesQuery();
	/**
	*	获的拼音查询器
	*/
	static	SpellQuery*	GetSpellQuery();
	/**
	*	获的拼写查询器
	*/
	static	StrokesOrderQuery*	GetStrokesOrderQuery();
protected :
	/**
	*	型别转换
	*/
	template	<class	TQuery>
	struct		TypeTraits
	{
	};
	/**
	*	获得特定的查询器
	*/
	template	<class	TQuery>
	static	TQuery*		GetQuery( TypeTraits<TQuery> )
	{
		static	TQuery		s_Query;
		static	BOOL		bInit	=	FALSE;
		
		// 首次使用初始化
		if	( !bInit )
		{
			if ( !s_Query.Initialize( &s_WordTable ) )
				return	NULL;
			else
				bInit	=	TRUE;
		}
		
		return	&s_Query;
	}
protected :
	/**
	*	所有汉字表
	*/
	static	WordTable	s_WordTable;
	/**
	*	部首表
	*/
	static	BSWord		s_BSWordTable[];
	friend	class	BSWords;
};
/**
*	字典生成器
*/
class	ChineseDictionaryMaker
{
public :
	/**
	*	制作字典
	*/
	static	BOOL	Make( const TCHAR*	szSpell, 
						  const TCHAR*	szBS,
						  const	TCHAR*	szStrokes );
protected :
	typedef		map<Word, ChineseDictionary::WordComment>		WordTable;
	/**
	*	处理拼音
	*/	
	static BOOL	ProcessSpell( const TCHAR* szSpell, WordTable& wtbl );
	/**
	*	处理部首
	*/
	static BOOL	ProcessBS( const TCHAR* szBS, WordTable& wtbl );
	/**
	*	处理笔画
	*/
	static	BOOL	ProcessStrokes( const TCHAR* szStrokes, WordTable& wtbl );
}; // end of DictionaryMaker
/**
*	部首比较器
*/
struct		BSLess
{
	/**
	*	比较wd1和wd2大小
	*	@param	如果wd1>wd2返回true, 否则为false
	*/
	BOOL	operator()( Word wd1, Word wd2 )
	{
		return	wd1<wd2;
	}
};
/**
*	字符串比较器
*/	
struct		StringLess
{
	/**
	*	比较str1和str2大小
	*	@param	如果str1>str2返回true, 否则为false
	*/
	BOOL	operator()( const CString& str1, const CString& str2 ) const
	{
		return	str1<str2;
	}
};
/**
*	笔顺比较器
*/
struct		StrokesOrderLess	:	public StringLess
{
};
/**
*	拼音比较器
*/
struct		SpellLess	:	public StringLess
{
};
/**
*	笔画比较器
*/
struct		StrokesLess
{
	BOOL	operator( )( int n1, int n2 ) const
	{
		return	n1 < n2;
	} 
};
/**
*	字符串包含测试器
*/
struct	StringContainTester
{
	/**
	*	 判断strTest前半部分是否包含strPrefix
	*/
	static	BOOL	Contain(	const TCHAR* strTest, 
								const TCHAR* strPrefix )
	{
		int	index	=	0;
		while	( strTest[index] && strPrefix[index] )
		{
			if ( strTest[index] != strPrefix[index] )
				return	FALSE;
			index++;
		}
		return	strTest[index] ||
				strTest[index] == strPrefix[index] ? TRUE	: FALSE;
				
	}
};
/**
*	拼音包含测试器
*/
struct	SpellContainTester	:	public StringContainTester
{	
};
/**
*	笔顺包含测试器
*/
struct	StrokesOrderContainTester	:	public StringContainTester
{	
};
/**
*	中文输入法
*/
class	ChineseInputer
{
public :
	/**
	*	汉字枚举器
	*/
	typedef		list<Word>		WordEnumerator;
	/**
	*	输入器
	*/
	class	Inputer
	{
	public :
		/**
		*	输入模式
		*/
		enum
		{
			/**
			*	输入拼音
			*/
			Input_Spell	= 0, 
			/** 
			*	输入部首 
			*/
			Input_BS,
			/**
			*	输入笔画
			*/
			Input_Strokes,
			/**
			*	输入笔顺
			*/
			Input_StrokesOrder
		};  // end of input state 
		/**
		*	构造函数
		*/
		Inputer();
		/**
		*	设置输入模式
		*/
		void	SetMode( int nMode );
		/**
		*	获得输入模式
		*/
		int		GetMode() const;
		/**
		*	获得所有输入
		*/	
		CString	GetInputs() const;
		/**
		*	输入字符
		*/
		void	Put( TCHAR c );
		/**
		*	输入字符串
		*/
		void	Put( const TCHAR* szChars );
     	/**
		*	输入法重置
		*/
		void	Reset();
		/**
		*	获得输入的拼音
		*/
		CString	GetSpell() const;
		/**
		*	获得输入的部首
		*/
		CString	GetBS() const;
		/**
		*	获得输入的笔顺
		*/
		CString	GetStrokesOrder() const;
		/**
		*	获得输入的笔画
		*/
		CString	GetStrokes() const;
	protected :
		/**
		*	获得原始串
		*/
		CString	GetUnparse() const;
	protected :
		/**
		*	输入解析器
		*/
		class	InputParser
		{
		public :
			/**
			*	构造函数
			*/
			InputParser( const CString& str );
			/**
			*	获得输入的拼音
			*/
			const CString&	GetSpell() const
			{
				return	m_strSpell;
			};
			
			/**
			*	获得输入的部首
			*/
			const CString&	GetBS() const
			{
				return	m_strBS;
			};
			
			/**
			*	获得输入的笔顺
			*/
			const CString&	GetStrokesOrder() const
			{
				return	m_strStrokesOrder;
			};
			
			/**
			*	获得输入的笔画
			*/
			const CString&	GetStrokes() const
			{
				return	m_strStrokes;
			};
		protected :
			/**
			*	解析函数
			*/
			BOOL	Parse( const CString& str );
	
		protected :
			/**
			*	需要解析得字符串
			*/
			CString		m_strForParse;
			/**
			*	拼音	
			*/
			CString		m_strSpell;
			/**
			*	笔顺
			*/
			CString		m_strStrokesOrder;
			/**
			*	笔画
			*/
			CString		m_strStrokes;
			/**
			*	部首
			*/
			CString		m_strBS;
		};
	public :
		/**
		*	拼音输入码分隔符
		*/
		static	const TCHAR	s_cSpellLeft, s_cSpellRight;
		/**
		*	部首输入码分隔符
		*/
		static	const TCHAR	s_cBSLeft, s_cBSRight;
		/**
		*	笔画输入码分隔符
		*/
		static	const TCHAR	s_cStrokesLeft, s_cStrokesRight;
		/**
		*	笔顺输入码分隔符
		*/
		static	const TCHAR	s_cStrokesOrderLeft, s_cStrokesOrderRight;
		/**
		*	分割字符
		*/
		static	TCHAR	s_cDividTable[4][2];
	
		/**
		*	分别指左右分隔符
		*/
		enum
		{
			begin	=	0,
			end		=	1
		};
	protected :
		/**
		*	当前输入模式
		*/
		int		m_uMode;
		/**
		*	已经输入的所有码
		*/
		CString	m_strInputs;
	};
	/**
	*	构造函数
	*/
	ChineseInputer();
	/**
	*	排序器
	*/
	class	Sorter	
	{
	protected :
		/**
		*	排序模式	
		*/
		Sorter( int nMode ) : m_nMode(nMode)	{ }
	public	:
		/**
		*	输出汉字排序模式
		*/
		enum
		{
		/**
		*	不排序
			*/
			OrderByNone,
				
			/**
			*	按部首排序
			*/
			OrderByBS,
			
			/**
			*	按拼音排序
			*/
			OrderBySpell,
			
			/**
			*	按笔画排序
			*/
			OrderByStrokes,
			
			/**
			*	按笔顺排序
			*/
			OrderByStrokesOrder
		};
		/**
		*	排序
		*/
		virtual		void	Sort( WordEnumerator& enumer )	=	0;
		/**
		*	判断排序器是否相等
		*/
		BOOL	operator==( const Sorter& sb ) const
		{
			return	m_nMode == sb.m_nMode;
		}
		/**
		*	判断是否不等
		*/
		BOOL	operator!=( const Sorter& sb ) const
		{
			return	m_nMode != sb.m_nMode;
		}
		/**
		*	获得排序模式
		*/	
		int		GetMode() const
		{
			return	m_nMode;
		}
		
	protected :
		/**
		*	排序模式
		*/
		int		m_nMode;
	};
	/**
	*	根据输入码， 查询汉字
	*/
	BOOL	QueryWords(  WordEnumerator& enumer, Sorter*	pSorter=NULL );
	typedef		ChineseDictionary::BSQuery		BSQuery;
	/**
	*	获得部首查询器
	*/
	BSQuery*	GetBSQuery()
	{
		return	ChineseDictionary::GetBSQuery( );
	}
	typedef		ChineseDictionary::SpellQuery	SpellQuery;
	/**
	*	获得查询查询器
	*/
	SpellQuery*	 GetSpellQuery( )
	{
		return	ChineseDictionary::GetSpellQuery();
	}
	typedef		ChineseDictionary::StrokesQuery	StrokesQuery;
	/**
	*	获得笔画查询器
	*/
	StrokesQuery*	 GetStroksQuery()
	{
		return	ChineseDictionary::GetStrokesQuery();
	}
	typedef		ChineseDictionary::StrokesOrderQuery	StrokesOrderQuery;
	/**
	*	获得笔顺查询器
	*/
	StrokesOrderQuery*	GetStrokesOrderQuery()
	{
		return	ChineseDictionary::GetStrokesOrderQuery();
	}
	/**
	*	获得输入器
	*/
	Inputer*	GetInputer();
protected :
	/**
	*	输入器
	*/
	Inputer		m_Inputer;
protected :
	/**
	*	查询过滤器
	*/
	class	QueryFilter
	{
	public :
		QueryFilter( const TCHAR* szFilter ) : m_strFilter(szFilter)
		{
		}
		/**
		*	析构函数
		*/	
		~QueryFilter()	{ }
		/**
		*	查询
		*/
		virtual		BOOL	QueryWords( WordEnumerator& enumer )	=	0;
		/**
		*	过滤字
		*/
		virtual		BOOL	Pass( Word wd )	=	0;	
		/**
		*	获得过滤器名称
		*/
		const CString&	GetFilter() const
		{
			return	m_strFilter;
		}
	protected :
		const	ChineseDictionary::WordComment&	GetComment(Word wd) 
		{
			ChineseDictionary::WordItemRef ref		=	ChineseDictionary::Get(wd);
			ASSERT ( ref != ChineseDictionary::NullWordItemRef );
			return ref.GetComment( );
		}
	protected :
		/**
		*	过滤器
		*/
		CString		m_strFilter;
	};
	/**
	*	拼音过滤器
	*/
	class	SpellFilter	:	public QueryFilter
	{
	public :
		/**
		*	构造函数
		*/
		SpellFilter( const TCHAR* szSpell );
		~SpellFilter() { }
		/**
		*	查询
		*/
		BOOL	QueryWords( WordEnumerator& enumer );
		/**
		*	过滤字
		*/
		BOOL	Pass( Word wd );	
	};
	/**
	*	部首过滤器
	*/
	class	BSFilter	:	public QueryFilter
	{
	public :
		/**
		*	构造函数
		*/
		BSFilter( const TCHAR* szBS );
		/**
		*	查询
		*/
		BOOL	QueryWords( WordEnumerator& enumer );
		/**
		*	过滤字
		*/
		BOOL	Pass( Word wd );	
	};
	/**
	*	笔画过滤器
	*/
	class	StrokesFilter	:	public QueryFilter
	{
	public :
		/**
		*	构造函数
		*/
		StrokesFilter( const TCHAR* szBS );
		/**
		*	查询
		*/
		BOOL	QueryWords( WordEnumerator& enumer );
		/**
		*	过滤字
		*/
		BOOL	Pass( Word wd );	
		/**
		*	笔画数
		*/
		int		GetStrokes() const
		{
			return	m_nStrokes;
		};
	protected :
		/**
		*	笔画数
		*/
		int		m_nStrokes;
	
	};
	/**
	*	笔顺过滤器
	*/
	class	StrokesOrderFilter	:	public QueryFilter
	{
	public :
		/**
		*	构造函数
		*/
		StrokesOrderFilter( const StrokesOrder&	sodr );
		/**
		*	查询
		*/
		BOOL	QueryWords( WordEnumerator& enumer );
		/**
		*	过滤字
		*/
		BOOL	Pass( Word wd );	
	};
	/**
	*	查询代理器
	*/
	class	QueryBroker
	{
	public :
		/**
		*	析构函数
		*/
		~QueryBroker();
		/**
		*	加入过滤器
		*/
		void	AddFilter(	QueryFilter* pFilter, BOOL	bAutoDel=FALSE );
		/**
		*	查询
		*/
		BOOL	QueryWords( WordEnumerator& enumer );
	protected :
		/**
		*	过滤器集合
		*/
		vector<QueryFilter*>		m_vFilters;
		/**
		*	自动删除标记
		*/
		vector<BOOL>				m_vDeletes;
	};
	/**
	*	拼音排序
	*/
	class	SpellSort	:	public Sorter
	{
	public :
		/**
		*	排序器构造函数
		*/
		SpellSort() : Sorter(OrderBySpell) {};
		/**
		*	排序
		*/
		void	Sort( WordEnumerator& enumer );
		/**
		*	获得前缀
		*/
		const	CString&	GetPrefix() const
		{
			return	m_strSpellPrefix;
		}
		/**
		*	设置前缀
		*/
		void	SetPrefix( const TCHAR* szPrefix )
		{
			m_strSpellPrefix	=	szPrefix;
		}
	protected :
		/**
		*	排序得主拼音
		*/
		CString		m_strSpellPrefix;
	};
	/**
	*	部首排序
	*/
	class	BSSort	:	public Sorter
	{
	public :
		/**
		*	排序器构造函数
		*/
		BSSort() : Sorter(OrderByBS) {};
		/**
		*	排序
		*/
		void	Sort( WordEnumerator& enumer );
	};
	/**
	*	笔画排序
	*/
	class	StrokesSort	:	public Sorter
	{
	public :
		/**
		*	排序器构造函数
		*/
		StrokesSort() : Sorter(OrderByStrokes) {};
		/**
		*	排序
		*/
		void	Sort( WordEnumerator& enumer );
	};
	/**
	*	笔顺排序
	*/
	class	StrokesOrderSort	:	public Sorter
	{
	public :
		/**
		*	排序器构造函数
		*/
		StrokesOrderSort() : Sorter(OrderByStrokesOrder) {};
		/**
		*	排序
		*/
		void	Sort( WordEnumerator& enumer );
	};
	/**
	*	空排序器
	*/
	class	NullSort			:	public Sorter
	{
	public :
		/**
		*	排序器构造函数
		*/
		NullSort() : Sorter(OrderByNone) {};
		/**
		*	排序
		*/
		void	Sort( WordEnumerator& enumer )	{};
	};
public :
	/**
	*	组合排序器
	*/
	class	CompositeSort	:	public SpellSort
	{
	public :
		/**
		*	构造函数
		*/
		CompositeSort()  { m_nMode	=	-1;}
		
		/**
		*	加入排序模式
		*/
		void	AddMode( int uMode );
		
		/**
		*	排序
		*/
		void	Sort( WordEnumerator& enumer );
		
		/**
		*	清除所有模式	
		*/
		void	ClearModes();
		
	protected :
		/**
		*	排序模式
		*/
		vector<int>		m_vModes;
	};
	/**
	*	空排序器
	*/
	static	NullSort*		GetNullSort();
	/**
	*	拼音排序器
	*/
	static	SpellSort*		GetSpellSort();
	/**
	*	笔画排序器
	*/
	static	StrokesSort*	GetStrokesSort();
	/**
	*	部首排序器
	*/
	static	BSSort*			GetBSSort();
	/**
	*	笔顺排序器
	*/
	static	StrokesOrderSort*	GetStrokesOrderSort();
	/**
	*	组合排序起
	*/
	static	CompositeSort*	GetCompositeSort();
};
/**
*	名称转换类
*		将中文名转换成拼音名
*/
class	NameTransform
{
public :
	/**
	*	将中文名转换成拼音文件名
	*/
	static	BOOL	Chinese2PY( const TCHAR* szName, TCHAR* szNewName )
	{
		const char*	pCurSrc	=	szName;
		char*		pCurDst	=	szNewName;
		while ( *pCurSrc )
		{
			if ( *pCurSrc > 0 ) // digit and char
			{
				*pCurDst++	=	*pCurSrc++;
			}
			else // chinese
			{
				char	 strWord[3];
				strWord[0]	=	*pCurSrc;
				strWord[1]	=	*(pCurSrc+1);
				strWord[2]	=	'';
				
				ChineseDictionary::WordItemRef wordRef	=	ChineseDictionary::Get( Word(strWord) );
				
				if ( wordRef == ChineseDictionary::NullWordItemRef )
					return	FALSE;
				
				// 获得第一拼音
				const SpellGroup& spells	=	wordRef.GetComment().GetSpellGroup();
				
				SpellGroup::const_iterator it = spells.begin();
				CString	strEnglishName	=	*it;
				
				int		nLen	=	strEnglishName.GetLength();
				strncpy( pCurDst, strEnglishName, nLen );
				
				pCurSrc +=	2;
				pCurDst	+=	nLen;
			}
		}
		
		*pCurDst	=	'';
		return	TRUE;
	}
};
//=========================================================================================
//	拼音组
//=========================================================================================
inline
SpellGroup::SpellGroup()
{
	m_vSpell.reserve(3);
}
inline
SpellGroup::SpellGroup( const TCHAR* szSpellGroup )
{
	AddGroup( szSpellGroup );
}
inline
int		SpellGroup::GetCount() const
{
	return	m_vSpell.size();
}
};
#endif

						