mmidictfunc.c

是一个手机功能的模拟程序

/*******************************************************************************

					CONDAT (UK)

********************************************************************************                                                                              

 This software product is the property of Condat (UK) Ltd and may not be
 disclosed to any third party without the express permission of the owner.                                 
                                                                              
********************************************************************************

 $Project name:	Basic MMI                                                      
 $Project code:	BMI (6349)                                                           
 $Module:		Supplementary services
 $File:		    Mmidictfunc.c
 $Revision:		1.0                                                       
                                                                              
 $Author:		hxl(Mobile Innovation)                                                         
 $Date:		    28/06/02                                                      
                                                                               
********************************************************************************
                                                                              
 Description

    This module provides the supplementary services functionality

  
********************************************************************************
 $History: Mmidictfunc.c

	01/08/02 			huangxl creat.	
	   
 $End

*******************************************************************************/

#define ENTITY_MFW

#include <stdio.h>
#include<string.h>
#include<ctype.h>

#include <stdlib.h>
#if defined (NEW_FRAME)

#include "typedefs.h"
#include "vsi.h"
#include "pei.h"
#include "custom.h"
#include "gsm.h"

#else

#include "stddefs.h"
#include "custom.h"
#include "gsm.h"
#include "vsi.h"

#endif

#include"mmidictdata.c"

#define GETBIT(p,n) (p[n/8]&(0x80>>(n%8))&0xff)

#ifdef _INNOVATION_EMULATOR_
static void decode(const char*in, char*out) 
#else
static inline void decode(const char*in, char*out) 
#endif
{
	int i;
	int n=0;
	int cn=0;
	for(i=0;;i++) {
		if(GETBIT(in,i))
			n = tree_array[n].r;
		else
			n = tree_array[n].l;
		if(tree_array[n].v) {
			out[cn]=tree_array[n].v;
			if(out[cn]==1) {
				out[cn]=0;
				break;
			}
			cn++;
			n=0;
		}
	}
}

#ifdef _INNOVATION_EMULATOR_
static int decode2(const char*in,char*out,char*out2)
#else
static inline int decode2(const char*in,char*out,char*out2)
#endif
{
	int i;
	int n=0;
	int cn=0;
	char flag=0;
	for(i=0;;i++) {
		if(GETBIT(in,i))
			n = tree_array[n].r;
		else
			n = tree_array[n].l;
		if(tree_array[n].v) {
			if(!flag) {
				out[cn]=tree_array[n].v;
				if(out[cn]==1) {
					out[cn]=0;
					cn=0;
					n=0;
					flag=1;
					continue;
				}
				cn++;
				n=0;
			} else {
				out2[cn]=tree_array[n].v;
				if(out2[cn]==1) {
					out2[cn]=0;
					break;
				}
				cn++;
				n=0;
			}
		}
	}
	return (i+8)/8;
}

static int stricmp(const char* s1,const char* s2)
{
      /*--------------------------------------------------------------------*/
      /* ADDRESSES ARE NOT WORD ALIGNED - SO SIMPLY COMPARE BYTE BY BYTE.   */
      /*--------------------------------------------------------------------*/
      unsigned char *st1 = (unsigned char *)s1;
      unsigned char *st2 = (unsigned char *)s2;
      unsigned char ch1;
      int    diff;

      while (!(diff = (ch1 = tolower(*st1++)) - tolower(*st2++)) && ch1 != 0) ;
      return diff;
}
static char _ebuf[32];
static char _ybuf[32];

int dict_english_find(char*w)
{
	int first,last,middle;
	int size;
	
	first = 0;
	size = sizeof(bmi_dictdata)/sizeof(char*);
	last= size-1;
	while(first!=last) {
		int rc=0;
		middle = (last-first)/2 + first;
		decode(bmi_dictdata[middle]+wstrlen(bmi_dictdata[middle])+3,_ebuf);
		rc = stricmp(w,_ebuf);
		if(rc>0)
			first = ++middle;
		else if(rc<0)
			last = middle;
		else{
			break;
		}
	}
	return middle;
}

#ifdef _INNOVATION_EMULATOR_
static char *_wstrstr(const char *str1, const char *str2)
#else
static inline char *_wstrstr(const char *str1, const char *str2)
#endif
{
   unsigned char *s1 = (unsigned char *)str1;
   unsigned char *s2 = (unsigned char *)str2;
   const unsigned char *cmp;
   const unsigned char *wpos;

   int wordlen=wstrlen((char *)str1)-1; //hxl add for unicode

   s1++;   //hxl add for unicode
   s2++;
   /*----------------------------------------------------------------------*/
   /* TRY EVERY POSITION IN THE CONTROL STRING                             */
   /*----------------------------------------------------------------------*/
//   for (wpos = s1; *s1; wpos = ++s1)
   for (wpos = s1; wordlen; wpos = ++s1)
   {
//	  if(*wpos<0xa1||*wpos>0xfe) //Ascii char,skip
//	  	continue;
	   if(*wpos==0x0){ //Ascii char,skip  ,hxl changed for unicode
		   s1++;
		   wordlen-=2;
	  	   continue;
	   }

      cmp = s2;
 	  
      do
      {
	 /*----------------------------------------------------------------*/
	 /* AT END OF COMPARISON STRING, MUST HAVE A MATCH OR EMPTY STRING */
	 /*----------------------------------------------------------------*/
	 	if (!*cmp)  return (char *)s1;
 
	 /*----------------------------------------------------------------*/
	 /* AT END OF CONTROL STRING, NO MATCH IS POSSIBLE                 */
	 /*----------------------------------------------------------------*/
	 	if (!*wpos) return NULL;
 
      } while (*wpos++ == *cmp++);
      s1++;
	  wordlen-=2; //hxl add for unicode
   }
   return NULL;
}

static int _index;
int dict_chinese_find_first(const char* w)
{
	int size;
	size = sizeof(bmi_dictdata)/sizeof(char*);
	for(_index=0;_index<size;_index++)
		if(_wstrstr(bmi_dictdata[_index],w))
			return _index;
	return -1;
}
int dict_chinese_find_next(const char* w)
{
	int size;
	int i = _index;
	size = sizeof(bmi_dictdata)/sizeof(char*);
	for(i++;i<size;i++)
		if(_wstrstr(bmi_dictdata[i],w))
			return _index=i;
	return -1;
}
int dict_chinese_find_back(const char* w)
{
	int size;
	int i = _index;
	size = sizeof(bmi_dictdata)/sizeof(char*);
	for(i--;i>=0;i--)
		if(_wstrstr(bmi_dictdata[i],w))
			return _index = i;
	return -1;
}
int dict_chinese_find_total(const char* w,signed short *idx)
{
	int size;
	int total=-1;
	int	i;
	size = sizeof(bmi_dictdata)/sizeof(char*);
	for(i=0;i<size;i++){
		if(_wstrstr(bmi_dictdata[i],w)){
			if(total==-1){
				total=0;
				_index=i;
				*idx=_index;
			}
			total++;
		}
	}
	return total;
}

 char dict_book(int index)
{
	if(index>=sizeof(bmi_dictdata)/sizeof(char*)||index<0)
		return 0;
	return (char)*(bmi_dictdata[index]+wstrlen(bmi_dictdata[index])+2);
}
char* dict_eng(int index) 
{
	if(index>=sizeof(bmi_dictdata)/sizeof(char*)||index<0)
		return NULL;
	decode(bmi_dictdata[index]+wstrlen(bmi_dictdata[index])+3,_ebuf);
	return _ebuf;
}

char* dict_yb(int index)
{
	if(index>=sizeof(bmi_dictdata)/sizeof(char*)||index<0)
		return NULL;
	decode2(bmi_dictdata[index]+wstrlen(bmi_dictdata[index])+3,_ebuf,_ybuf);
	return _ybuf;
}

 char* dict_chn(int index)
{
	if(index>=sizeof(bmi_dictdata)/sizeof(char*)||index<0)
		return NULL;
	return (char*)(bmi_dictdata[index]);
 }

 
static int _bookindex=-1;
static char _book;
static int _i=-1;
int dict_getTotalByBook(char book)
{
	int i,t=0;
	for(i=0;i<8;i++) 
		if(book&1<<i)
			t+=bmi_dicttotal[i];
	return t;		
}

int dict_getWordByBook(int index,char book)
{
	int i;
	char dir=0;
	int size = sizeof(bmi_dictdata)/sizeof(char*);
 	if(book == _book) {
  		if(index<=_bookindex/2 || _bookindex == -1) {
   			_i = -1;
  			_bookindex = -1;
 			i = 0;	
  		} else if(index < _bookindex) {
  			i = _i-1;
  			dir = 1;
  		} else if(index == _bookindex)
   			return _i;
  		else
   			i = _i+1;
 	} else {
  		_i = -1;
  		_bookindex = -1;
  		_book = book;
  		i = 0;
 	}
 	if(dir==0)
	for(;i<size;i++) {
  		if(*(bmi_dictdata[i]+wstrlen(bmi_dictdata[i])+2)&book) {
  			_i = i;
   			_bookindex++;
  			if(_bookindex == index)
   				return _i;
  		}
 	}
	else
	for(;i>=0;i--) {
  		if(*(bmi_dictdata[i]+wstrlen(bmi_dictdata[i])+2)&book) {
  			_i = i;
   			_bookindex--;
  			if(_bookindex == index)
   				return _i;
  		}
 	}

 	return -1;
}