dict_get_word.c

在mtk平台上开发的电子词典源码

		while((ii<end_id || cmp_flag==1) && offset<GET_WORD_MAX_NUM && ii<chn_word_num-2)
		{
			FS_Seek(fp, LONG_POINT[ii-start_id], FS_FILE_BEGIN);
			FS_Read(fp, Get_Word, 128, &read_byte);
			delete_tab(Get_Word, 128);
			if(cmp_flag==1 || memcmp(Get_Word, Input, strlen((char *)Input))==0)
			{
				////添加到列表
				ll = strlen((char *)Get_Word);
				memcpy(pz, Get_Word, ll+1);
				pz+=(ll+1);
				////纪录信息
				note_word_info(Get_Word, LONG_POINT[ii-start_id], LONG_POINT[ii-start_id+1]);
				cmp_flag=1;
				offset++;
			}////if()

			ii++;
		}////while(ii)
	}////联想模式
	else if(page==1)////下翻页
	{
		while((ii<end_id || cmp_flag==1) && offset<GET_WORD_MAX_NUM && ii<chn_word_num-2)
		{
			FS_Seek(fp, LONG_POINT[ii-start_id], FS_FILE_BEGIN);
			FS_Read(fp, Get_Word, 128, &read_byte);
			delete_tab(Get_Word, 128);
			if(cmp_flag==1 || memcmp(Get_Word, Input, strlen((char *)Input))==0)
			{
				if(cmp_flag==0){ ii++; cmp_flag=1; continue; }
				////添加到列表
				ll = strlen((char *)Get_Word);
				memcpy(pz, Get_Word, ll+1);
				pz+=(ll+1);
				////纪录信息
				note_word_info(Get_Word, LONG_POINT[ii-start_id], LONG_POINT[ii-start_id+1]);
				cmp_flag=1;
				offset++;
			}////if()

			ii++;
		}////while(ii)
	}////下翻页
	else////上翻页
	{
		while(ii<end_id)
		{
			FS_Seek(fp, LONG_POINT[ii-start_id], FS_FILE_BEGIN);
			FS_Read(fp, Get_Word, 128, &read_byte);
			delete_tab(Get_Word, 128);
			if(memcmp(Get_Word, Input, strlen((char *)Input))==0)
			{ break; }

			ii++;
		}////while(ii)

		if(ii<end_id)////可以上翻页
		{
			if(ii<GET_WORD_MAX_NUM){ start_id=0; }
			else{ start_id = ii-GET_WORD_MAX_NUM; }
			ll = 0-single_word_num*sizeof(struct CHN_WORD_STRUCT)-(chn_word_num-start_id)*4;
			FS_Seek(fp, ll, FS_FILE_END);
			if(chn_word_num-start_id >= 500)
			{ FS_Read(fp, Word_Area_List, 2000, &read_byte); }
			else
			{ FS_Read(fp, Word_Area_List, (chn_word_num-start_id)*4, &read_byte); }

			offset=0;ii=start_id;
			while(offset<GET_WORD_MAX_NUM && ii<chn_word_num-2)
			{
				FS_Seek(fp, LONG_POINT[ii-start_id], FS_FILE_BEGIN);
				FS_Read(fp, Get_Word, 128, &read_byte);
				delete_tab(Get_Word, 128);
				////添加到列表
				ll = strlen((char *)Get_Word);
				memcpy(pz, Get_Word, ll+1);
				pz+=(ll+1);
				////纪录信息
				note_word_info(Get_Word, LONG_POINT[ii-start_id], LONG_POINT[ii-start_id+1]);
				offset++;
				ii++;
			}////while(ii)
		}////if(可以上翻页)
	}////上翻页
	////////////////////////////////////////////

	memset(pz, 0, 8);
	FS_Close(fp);
	return((int)offset);
}
//////////////////////////////////////////////////////////////////

////根据输入，得到汉字词的解释
int get_Chinese_word_explain
(
	unsigned char *Input,
	unsigned char *explain
)
{
	int fp=0;
	unsigned long explain_start=0, explain_end=0;
	unsigned char data_buf[1024];
	unsigned char *pz=NULL;
	unsigned long offset=0, ii=0, ll=0;
	struct CHN_WORD_STRUCT *chn_word_struct_list=NULL;
	unsigned long *LONG_POINT=NULL;
	unsigned long single_word_num=0;
	unsigned long chn_word_num=0;
	int cmp_flag=0;
	unsigned long start_id=0, end_id=0;
	unsigned int read_byte=0;
	///////////////////////////////////

	if(Input==NULL || explain==NULL) return 0;

	for(ii=0; ii<GET_WORD_MAX_NUM; ii++)
	{
		if(strcmp((char *)Word_Info_List[ii].word, (char *)Input)==0)
		{
			explain_start = Word_Info_List[ii].data_start;
			explain_end = Word_Info_List[ii].data_end;
			break;
		}
	}////for(ii)

	if(ii<GET_WORD_MAX_NUM)////有信息
	{
		if(explain_end<=explain_start) return 0;

		fp = MY_OPENFILE(DISK_TYPE, "dict\\chn_eng_data.bjld", FS_READ_ONLY);
		if(fp<0){ return 0; }
		
		FS_Seek(fp, explain_start, FS_FILE_BEGIN);
		memset(data_buf, 0, 1024);
		FS_Read(fp, data_buf, explain_end-explain_start, &read_byte);
		memset(data_buf+explain_end-explain_start, 0, 4);
		FS_Close(fp);

		pz=(unsigned char *)strchr((char *)data_buf, '\t');
		if(pz==NULL){ return 0; }
		pz++;
		ii = explain_end-explain_start-(unsigned long)(pz-data_buf);
		decode_data(pz, ii);
		memcpy(explain, pz, ii);
		memset(explain+ii, 0, 4);
		return 1;
	}////if(ii)

	////搜索一下
	fp = MY_OPENFILE(DISK_TYPE, "dict\\chn_eng_data.bjld", FS_READ_ONLY);
	if(fp<0){ return 0; }

	////为节省空间，在这里重复利用Word_Area_List[]数组
	chn_word_struct_list = (struct CHN_WORD_STRUCT *)Word_Area_List;
	FS_Seek(fp, 0-sizeof(struct CHN_WORD_STRUCT), FS_FILE_END);
	FS_Read(fp, chn_word_struct_list, sizeof(struct CHN_WORD_STRUCT), &read_byte);
	single_word_num = chn_word_struct_list->start_ID;

	////搜索
	FS_Seek(fp, 0-single_word_num*sizeof(struct CHN_WORD_STRUCT), FS_FILE_END);
	offset=0;ii=0;
	cmp_flag = 1;
	while(offset<single_word_num-2)
	{
		if(offset%248==0)
		{
			////Word_Area_List[]数组的空间正好是2000 byte
			if(single_word_num-2-offset>=250)
			{ FS_Read(fp, chn_word_struct_list, 2000, &read_byte); }
			else{ FS_Read(fp, chn_word_struct_list, (single_word_num-2-offset)*8, &read_byte); }
			ii=offset;
		}

		cmp_flag = memcmp(chn_word_struct_list[offset-ii].chn_word, Input, 2);
		if(cmp_flag==0)////找到
		{
			start_id = chn_word_struct_list[offset-ii].start_ID;
			end_id = chn_word_struct_list[offset-ii+1].start_ID;
			break;
		}

		offset++;
	}////while(offset)

	if(cmp_flag!=0){ FS_Close(fp); return 0; }////没有找到

	FS_Seek(fp, 0-4-single_word_num*sizeof(struct CHN_WORD_STRUCT), FS_FILE_END);
	FS_Read(fp, &chn_word_num, 4, &read_byte);
	ll = 0-single_word_num*sizeof(struct CHN_WORD_STRUCT)-(chn_word_num-start_id)*4;
	FS_Seek(fp, ll, FS_FILE_END);
	////利用Word_Area_List[]的空间,足够大了
	if(chn_word_num-start_id >= 500)
	{ FS_Read(fp, Word_Area_List, 2000, &read_byte); }
	else
	{ FS_Read(fp, Word_Area_List, (chn_word_num-start_id)*4, &read_byte); }
	LONG_POINT = (unsigned long *)Word_Area_List;
	ii=start_id;
	while(ii<end_id)
	{
		FS_Seek(fp, LONG_POINT[ii-start_id], FS_FILE_BEGIN);
		FS_Read(fp, data_buf, 128, &read_byte);
		delete_tab(data_buf, 128);
		if(strcmp((char *)data_buf, (char *)Input)==0)
		{
			////纪录信息
			note_word_info(data_buf, LONG_POINT[ii-start_id], LONG_POINT[ii-start_id+1]);
			break;
		}////if()

		ii++;
	}////while(ii)
	FS_Close(fp);
	if(ii>=end_id){ return 0; }
	return(get_Chinese_word_explain(Input, explain));
}
int get_class_word_by_ID(unsigned long word_ID, int class_mode, unsigned char *word)
{
	int fp=0;
	unsigned long class_number=0;
	unsigned long start_byte=0, end_byte=0;
	unsigned char Get_word[128];
	unsigned int byte_num=0;
	//////////////////////
	
	if(word==NULL){ return 0; }
	fp = MY_OPENFILE(DISK_TYPE, (char *)CLASS_DATA_FILE_NAME, FS_READ_ONLY);
	if(fp<0){ return 0; }
	
	////总的分类种数, 总的单词数
	FS_Seek(fp, 0-8, FS_FILE_END);
	FS_Read(fp, &class_number, 4, &byte_num);
	///////////////////////////
	
	if((unsigned long)class_mode > class_number-1)////默认是普通词库
	{ FS_Close(fp); return 0; }////普通词库
	
	////当前分类索引
	FS_Seek(fp, 0+((unsigned long)class_mode-class_number)*sizeof(struct CLASS_WORD_INFO)-8, FS_FILE_END);
	FS_Read(fp, &class_word_info, sizeof(struct CLASS_WORD_INFO), &byte_num);
	if(word_ID >= class_word_info.alpha_index[26]-class_word_info.alpha_index[0])
	{ FS_Close(fp); return 0; }
	FS_Seek(fp, 0+(class_word_info.alpha_index[0]+word_ID)*8, FS_FILE_BEGIN);
	FS_Read(fp, &start_byte, 4, &byte_num);
	FS_Read(fp, &end_byte, 4, &byte_num);
	FS_Close(fp);
	
	Get_word_by_byte(Get_word, start_byte);////得到单词
	note_word_info(Get_word, start_byte, end_byte);////纪录信息
	memcpy(word, Get_word, strlen((char *)Get_word)+4);
	return 1;
}
int get_idiom_list(char *input,char *idiom_list,unsigned short *list_id)
{
	int fpData=0; //数据文件指针
	long list_num=0; //联表分区总数
	long count_num=0; //用于计算联表个数
	pidiom_list_info plist_info; //成语联表结构信息指针
	idiom_list_info list_info; //成语联表结构信息
	char flag=0;
	char *pch=NULL,*pch_list=idiom_list;
	short i=0;
	unsigned int read_byte=0;
	///////////////////////////////////

	//判断输入输出字符是否为空
	if( input==NULL || idiom_list==NULL )
	{
		return 0;
	}

	fpData = MY_OPENFILE(DISK_TYPE, "dict\\idiom_data.bjld", FS_READ_ONLY);
	if(fpData<0){ return 0; }

	FS_Seek(fpData, -8, FS_FILE_END);
	FS_Read(fpData, &list_num, 4, &read_byte);		//读取联表分区总数
	FS_Seek(fpData, -(16+list_num*8), FS_FILE_END);

	//查找输入字符所在分区并获得所在分区的信息
	while( count_num<list_num )
	{
		memset(idiom_list_buf,0,3328);
		FS_Read(fpData, idiom_list_buf, 8*400, &read_byte); //读取400个分区信息数据
		plist_info=(pidiom_list_info)idiom_list_buf;	 //用联表结构信息指针，以便查找

		//400个分区信息数据进行查找
		for(i=0; i<400 && count_num<list_num; i++)
		{
			//判断是否为所在分区
			if( memcmp(plist_info[i].first_word,input,2) == 0 )
			{
				list_info=plist_info[i];		//获得所在分区联表信息
				flag=1;
				break;
			}
			count_num++;
		}

		//如果找到就结束循环
		if(flag == 1)
		{
			break;
		}
	}

	//如果没有找到相应分区，结束程序
	if(flag == 0)
	{
		memset(idiom_list,0,256);
		FS_Close(fpData);
		return 1;
	}

	memset(idiom_list_buf, 0, 3328);
	FS_Seek(fpData, list_info.index, FS_FILE_BEGIN);
	FS_Read(fpData, idiom_list_buf, list_info.list_len, &read_byte); //读取成语联表数据
	memset(idiom_list_buf+list_info.list_len,0,8); //手机有可能多读数据,对多读部分清0
	pch=idiom_list_buf;

	//判断输入字符串是否为单个汉字
	if( strlen((char *)input) == 2 )
	{
		memset(idiom_list,0,256);

		//如果是单个汉字，生成相应联表
		for(i=0; i<GET_WORD_MAX_NUM && *(pch+2)!=0; i++)
		{
			memcpy(&list_id[i],pch,2);					//得到联表成语ID
			memcpy(pch,list_info.first_word,2);			//在联表数据缓冲中写入成语首汉字
			strcpy(pch_list,pch);						//将成语考入联表
			pch = strchr(pch, 0)+1;						//跳到缓冲中下一个成语
			pch_list = strchr(pch_list, 0)+1;			//跳到联表中下一个成语
		}
	}
	else
	{
		//如果不是单个汉字，进一步查找
		while( *(pch+2)!=0 )
		{
			//判断是否找到拼配成语
			if( memcmp(input+2, pch+2,strlen(input+2))==0 )
			{
				memset(idiom_list,0,256);
				for(i=0; i<GET_WORD_MAX_NUM && *(pch+2)!=0; i++)
				{
					memcpy(&list_id[i],pch,2);				//得到联表成语ID
					memcpy(pch,list_info.first_word,2);		//在联表数据缓冲中写入成语首汉字
					strcpy(pch_list,pch);					//将成语考入联表
					pch = strchr(pch, 0)+1;					//跳到缓冲中下一个成语
					pch_list = strchr(pch_list, 0)+1;		//跳到联表中下一个成语
				}
				break;
			}
			pch = strchr(pch+2, 0)+1;		//如不拼配，跳到下个
		}
	}

	FS_Close(fpData);			//关闭文件
	return 1;
}
int get_idiom_explain
(
	unsigned short idiom_id, //输入成语ID
	char *idiom_sound, //输出成语拼音
	char *idiom_explain //输出成语解释
	)
{
	int fpData=0; //成语词典数据文件指针
	long s_code_startbyte; //拼音目录在文件中的开始位置
	long e_index_startbyte; //解释索引在文件中的开始位置
	idiom_explain_info idiom_info; //成语解释索引信息
	short i=0; //循环控制短整型
	short *ps=NULL;										
	char *pch=idiom_sound;
	long idiom_num=0;
	unsigned int read_byte=0;
	//////////////////////////////////////
	
	//判断idiom_sound和idiom_explain是否为空
	if( idiom_sound==NULL || idiom_explain==NULL )
	{
		return 0;
	}
	
	//打开数据文件
	fpData = MY_OPENFILE(DISK_TYPE, "dict\\idiom_data.bjld", FS_READ_ONLY);
	if(fpData<0){ return 0; }
	
	FS_Seek(fpData, -4, FS_FILE_END);
	FS_Read(fpData, &idiom_num, 4, &read_byte); //读取成语词典的个数
	
	//判断输入的id是否在范围内
	if( idiom_id<1 || idiom_id>idiom_num )
	{ return 0; }