+
−/*******************************************************************************
+
−
+
−					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:	                                                      
+
− $Project code:	                                                           
+
− $Module:		
+
− $File:		    ATBPb.c
+
− $Revision:		                                                      
+
−                                                                              
+
− $Author:		Condat(UK)                                                         
+
− $Date:		                                                          
+
−                                                                               
+
−********************************************************************************
+
−                                                                              
+
− Description:
+
−    
+
−                        
+
−********************************************************************************
+
−
+
− $History: ATBPb.c
+
−
+
−    Jan 18, 2004 REF: CRR MMI-SPR-25332 xnkulkar
+
−    Description: Moving entries from Sim Card to phone memory fails. 
+
−    Solution: When entries are moved, corresponding updations are done in cache as well.
+
−	
+
−	   
+
− $End
+
−
+
−*******************************************************************************/
+
−
+
−#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 <stdio.h>
+
−#include <string.h>
+
−
+
−#include "mfw_mfw.h"
+
−#include "mfw_sys.h"
+
−
+
−#include "cus_aci.h"
+
−#include "prim.h"
+
−#include "pcm.h"
+
−
+
−#include "ATBPb.h"
+
−#include "ATBPb_i.h"
+
−
+
−/* Global data for phonebook */
+
−
+
−static T_PB_DATA *phonebook[PB_PHONEBOOKS_MAX] = {0};
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_pb_GetPhonebook
+
− 
+
− $Description:	Checks to see which file system is selected
+
−
+
− $Returns:		PB_OK					Action completed OK.
+
−				PB_FILEWRITEFAIL		File write encountered an error
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier
+
− 				current_type	Place to store type of phonebook selected.
+
− 
+
−*******************************************************************************/
+
−
+
−PB_RET	ATB_pb_GetPhonebook(SHORT phonebook_id, T_PB_TYPE *current_type)
+
−{
+
−	PB_RET 		result;
+
−	T_PB_DATA	*data	= ATB_hnd_GetPbData(phonebook_id);
+
−
+
−	tracefunction("ATB_pb_GetPhonebook");
+
−
+
−	if (data)
+
−	{
+
−		*current_type = data->current_type;
+
−		return PB_OK;
+
−	}
+
−		
+
−	result = FS_pb_GetPhonebook(phonebook_id, current_type);
+
−
+
−	return result;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_pb_SetPhonebook
+
− 
+
− $Description:	Select file system
+
−
+
− $Returns:		PB_OK					Action completed OK.
+
−				PB_FILEREADFAIL			File read encountered an error
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier
+
− 				current_type	Type of phonebook selected.
+
− 
+
−*******************************************************************************/
+
−
+
−PB_RET	ATB_pb_SetPhonebook(SHORT phonebook_id, T_PB_TYPE current_type)
+
−{
+
−	PB_RET 		result;
+
−	T_PB_DATA	*data	= ATB_hnd_GetPbData(phonebook_id);
+
−
+
−	tracefunction("ATB_pb_SetPhonebook");
+
−	
+
−	if (data)
+
−		data->current_type = current_type;
+
−	
+
−	result = FS_pb_SetPhonebook(phonebook_id, current_type);
+
−
+
−	return result;
+
−}
+
−
+
−		
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_pb_Initialise
+
− 
+
− $Description:	Initialise an instance of phonebook.  Dynamically allocates a record
+
− 				cache in RAM.  Creates the necessary file(s) if they do not already exist.
+
− 				Sorts the phonebook by name and by number, creating the appropriate
+
− 				index tables.
+
−				IMPORTANT: if the file reading is non-blocking - i.e. if a request to read
+
−				a file does not return with an answer straight away, but the system
+
−				awaits a callback - then "cache_max" must equal "records_max".  This
+
−				ensures that all records are stored in RAM and can be retrieved without
+
−				waiting for a response.  If the file reading is blocking, then cache_max
+
−				can be smaller than records_max.
+
−
+
−				The memory allocated by this operation will not be freed until
+
−				ATB_pb_Exit() is called.
+
−
+
− $Returns:		PB_OK					Action completed OK.
+
−				PB_EXCT					Action currently executing, callback awaited.
+
−										GI_pb_OK will be called if successful,
+
−										GI_pb_Error otherwise.
+
−				PB_BUSY					Failed, phonebook is busy.
+
−				PB_FILEREADFAIL			File read encountered an error
+
−				PB_FILEWRITEFAIL		File write encountered an error
+
−				PB_BOOKALREADYEXISTS 	Tried to initialise a phonebook that already
+
−										exists
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier
+
−				type			Type of phonebook.
+
−				records_max		Indicates the maximum number of entries the
+
−								phonebook can hold.
+
−				cache_max		Indicates the maximum number of records that the
+
−								PB will store concurrently in RAM.
+
−				alpha_max		Maximum size of unicode alpha tag in characters
+
−				number_max		Maximum size of phone number in digits
+
−				ext_max			Maximum size of extended data in bytes
+
−								
+
−*******************************************************************************/
+
−
+
−PB_RET	ATB_pb_Initialise(SHORT phonebook_id, T_PB_TYPE type, SHORT records_max, SHORT cache_max,
+
−	SHORT alpha_max, SHORT number_max, SHORT ext_max)
+
−{
+
−	T_PB_DATA *data;
+
−	
+
−	tracefunction("ATB_pb_Initialise()");
+
−	
+
−	/* Check to see if this phonebook has already been allocated */
+
−	
+
−	if (ATB_hnd_GetPbData(phonebook_id)!=NULL)
+
−	{
+
−		trace("* ERROR * - Phonebook already exists");
+
−		GI_pb_Error(phonebook_id, PB_INITIALISE, PB_BOOKALREADYEXISTS);
+
−		return PB_BOOKALREADYEXISTS;
+
−	}
+
−
+
−	/* Allocate memory for phonebook data */
+
−
+
−	data = (T_PB_DATA *)GI_pb_MemAlloc(sizeof(T_PB_DATA));
+
−	ATB_hnd_SetPbData(phonebook_id, data);
+
−	
+
−	data->records_max = records_max;
+
−	data->records_used = 0;
+
−	data->search_results = 0;
+
−
+
−	data->alpha_max = alpha_max;
+
−	data->number_max = number_max;
+
−	data->ext_max = ext_max;
+
−	
+
−	/* Allocate memory for index tables */
+
−	
+
−	data->name_table = (SHORT *)GI_pb_MemAlloc(records_max*sizeof(SHORT));
+
−	memset(data->name_table, 0, records_max*sizeof(SHORT));
+
−	data->number_table = (SHORT *)GI_pb_MemAlloc(records_max*sizeof(SHORT));
+
−	memset(data->number_table, 0, records_max*sizeof(SHORT));
+
−	data->search_table = (SHORT *)GI_pb_MemAlloc(records_max*sizeof(SHORT));
+
−	memset(data->search_table, 0, records_max*sizeof(SHORT));
+
−	data->in_memory = (SHORT *)GI_pb_MemAlloc(records_max*sizeof(SHORT));
+
−	memset(data->in_memory, PB_EMPTY_RECORD, records_max*sizeof(SHORT));
+
−
+
−	/* Allocate memory for cache */
+
−
+
−	data->cache_max = cache_max;
+
−	data->cache_size = 0;
+
−	data->cache	= (T_PB_RECORD **)GI_pb_MemAlloc(records_max*sizeof(T_PB_RECORD *));
+
−	memset(data->cache, 0, records_max*sizeof(T_PB_RECORD *));
+
−	
+
−	/* Set up command */
+
−	
+
−	data->command_id = PB_INITIALISE;
+
−	data->status	= PB_STATUS_INIT;
+
−	data->param.Initialise.type = type;
+
−	data->param.Initialise.records_max = records_max;
+
−	
+
−	return ATB_status_Initialise(phonebook_id);
+
−}
+
−
+
−/* Status function for Initialise */
+
−
+
−PB_RET ATB_status_Initialise(SHORT phonebook_id)
+
−{
+
−	T_PB_DATA		*data		= ATB_hnd_GetPbData(phonebook_id);
+
−	T_PB_INITIALISE	*Initialise;
+
−	SHORT				blocking;
+
−	PB_RET			result=PB_ERROR;
+
−
+
−	/* Ensure that phonebook exists */
+
−	if (!data)
+
−	{
+
−		trace("**ERROR** Phonebook does not exist");
+
−		return PB_BOOKDOESNOTEXIST;
+
−	}
+
−	
+
−	Initialise = &data->param.Initialise;
+
−	blocking = TRUE;
+
−	while (blocking)
+
−	{
+
−		switch(data->status)
+
−		{
+
−			case PB_STATUS_INIT:
+
−				trace("ATB_status_Initialise: INIT");
+
−				result = FS_pb_Initialise(phonebook_id, Initialise->type, Initialise->records_max,
+
−					data->alpha_max, data->number_max, data->ext_max);
+
−				
+
−				/* Select next state */
+
−				
+
−				data->status = PB_STATUS_EXEC;
+
−				Initialise->phys_index = 0;
+
−				Initialise->first_record = TRUE;
+
−				Initialise->record = ATB_pb_AllocRec(phonebook_id);
+
−				
+
−				/* Allow exit from function */
+
−				
+
−				if (result!=PB_OK)
+
−					blocking = FALSE;
+
−				break;
+
−
+
−			case PB_STATUS_EXEC:
+
−				trace("ATB_status_Initialise: EXEC");
+
−
+
−				/* Try to read in index tables from file system.  If we can't find them, the
+
−				 * records will be read in and sorted. */
+
−
+
−				if (Initialise->first_record)
+
−				{
+
−					result = FS_pb_ReadTables(phonebook_id, &data->records_used, data->name_table, data->number_table);
+
−					if (result==PB_OK)
+
−					{
+
−						/* Escape to PB_STATUS_COMPLETE */
+
−						result = PB_OK;
+
−						data->status = PB_STATUS_COMPLETE;
+
−						break;
+
−					}
+
−				}
+
−				/* If we've already read a record, and it's an existing record, add it to the
+
−				 * index tables and to the cache */
+
−				 
+
−				else
+
−				{	
+
−					if (Initialise->record->alpha.data[0]!=(USHORT)0xFFFF)
+
−					{
+
−						ATB_mem_UpdateCache(phonebook_id, Initialise->phys_index, Initialise->record);
+
−						ATB_index_AddRec(phonebook_id, INDEX_NAME, Initialise->phys_index, Initialise->record, NULL);
+
−						ATB_index_AddRec(phonebook_id, INDEX_NUMBER, Initialise->phys_index, Initialise->record, NULL);
+
−						data->records_used++;
+
−					}
+
−
+
−					Initialise->phys_index++;
+
−				}
+
−
+
−				/* Start processing after first record is read */
+
−				
+
−				Initialise->first_record = FALSE;
+
−				
+
−				/* If we haven't just read the last record, read the next one */
+
−				
+
−				if (Initialise->phys_index<data->records_max)
+
−				{
+
−					result = FS_pb_ReadRec(phonebook_id, Initialise->phys_index, Initialise->record);
+
−				}
+
−				else
+
−				{
+
−					/* Set next state as finished */
+
−					result = PB_OK;
+
−					data->status = PB_STATUS_COMPLETE;
+
−				}
+
−
+
−
+
−				/* Allow exit from function */
+
−				
+
−				if (result!=PB_OK)
+
−					blocking = FALSE;
+
−				break;
+
−
+
−			case PB_STATUS_COMPLETE:
+
−				trace("ATB_status_Initialise: COMPLETE");
+
−				blocking = FALSE;
+
−
+
−				/* Close file */
+
−
+
−				FS_pb_Finished(phonebook_id);
+
−				FS_pb_WriteTables(phonebook_id, data->records_used, data->name_table, data->number_table);
+
−				
+
−				/* Free the allocated record */
+
−
+
−				ATB_pb_FreeRec(phonebook_id, Initialise->record);
+
−				
+
−				/* Notify the GI of success */
+
−				GI_pb_OK(phonebook_id, data->command_id, NULL);
+
−				result = PB_OK;
+
−				data->status = PB_STATUS_NONE;
+
−				break;
+
−		}
+
−	}
+
−
+
−	return result;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_pb_Exit
+
− 
+
− $Description:	Frees memory associated with phonebook.  To be called when the
+
− 				phonebook is no longer required, or at shutdown.
+
−
+
− $Returns:		PB_OK		Action completed OK.
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier
+
− 
+
−*******************************************************************************/
+
−
+
−PB_RET ATB_pb_Exit(SHORT phonebook_id)
+
−{
+
−	T_PB_DATA *data = ATB_hnd_GetPbData(phonebook_id);
+
−	SHORT phys_index;
+
−
+
−	trace("ATB_pb_Exit");
+
−
+
−	/* Ensure that phonebook exists */
+
−	if (!data)
+
−	{
+
−		trace("**ERROR** Phonebook does not exist");
+
−		return PB_BOOKDOESNOTEXIST;
+
−	}
+
−	
+
−	for (phys_index = 0; phys_index<data->records_max; phys_index++)
+
−	{
+
−		if (data->cache[phys_index]!=NULL)
+
−			ATB_pb_FreeRec(phonebook_id, data->cache[phys_index]);
+
−	}
+
−
+
−	GI_pb_MemFree((UBYTE *)data->cache, data->records_max*sizeof(T_PB_RECORD *));
+
−	GI_pb_MemFree((UBYTE *)data->in_memory, data->records_max*sizeof(SHORT));
+
−	GI_pb_MemFree((UBYTE *)data->search_table, data->records_max*sizeof(SHORT));
+
−	GI_pb_MemFree((UBYTE *)data->number_table, data->records_max*sizeof(SHORT));
+
−	GI_pb_MemFree((UBYTE *)data->name_table, data->records_max*sizeof(SHORT));
+
−	
+
−	GI_pb_MemFree((UBYTE *)data, sizeof(T_PB_DATA));
+
−
+
−	ATB_hnd_SetPbData(phonebook_id, NULL);	
+
−	return PB_OK;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_pb_Status
+
− 
+
− $Description:	Returns PB_OK if the phonebook is ready for a new command,
+
− 				or PB_BUSY if the phonebook is busy.
+
−
+
− $Returns:		PB_OK		All tasks completed, phonebook ready.
+
− 				PB_BUSY		Commands currently executing.
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier
+
− 
+
−*******************************************************************************/
+
−
+
−PB_RET	ATB_pb_Status(SHORT phonebook_id)
+
−{
+
−	T_PB_DATA *data = ATB_hnd_GetPbData(phonebook_id);
+
−	PB_RET	result;
+
−
+
−	/* Ensure that phonebook exists */
+
−	if (!data)
+
−	{
+
−		trace("**ERROR** Phonebook does not exist");
+
−		return PB_BOOKDOESNOTEXIST;
+
−	}
+
−
+
−	// Jan 18, 2004 REF: CRR MMI-SPR-25332 xnkulkar
+
−    	// Description: Moving entries from Sim Card to phone memory fails. 
+
−    	// Solution: result should be set as PB_OK when PB_STATUS_COMPLETE is true also.
+
−	if ((data->status==PB_STATUS_NONE) ||(data->status==PB_STATUS_COMPLETE))
+
−		result = PB_OK;
+
−	else
+
−		result = PB_BUSY;
+
−	
+
−	return result;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_pb_Info
+
− 
+
− $Description:	Returns information about the phonebook, which will be returned
+
− 				in the data structure pointed to by phonebook_info.  The caller must
+
− 				allocate the T_PB_INFO structure.
+
−
+
− $Returns:		PB_OK		Action completed OK.
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier
+
−				phonebook_info	Pointer to data structure to contain phonebook
+
−								information (allocated by caller).
+
− 
+
−*******************************************************************************/
+
−
+
−PB_RET	ATB_pb_Info(SHORT phonebook_id, T_PB_INFO *phonebook_info)
+
−{
+
−	T_PB_DATA *data = ATB_hnd_GetPbData(phonebook_id);
+
−
+
−	/* Ensure that phonebook exists */
+
−	if (!data)
+
−	{
+
−		trace("**ERROR** Phonebook does not exist");
+
−		return PB_BOOKDOESNOTEXIST;
+
−	}
+
−	
+
−	phonebook_info->records_used = data->records_used;
+
−	phonebook_info->records_max = data->records_max;
+
−	phonebook_info->records_free = data->records_max - data->records_used;
+
−	phonebook_info->search_results = data->search_results;
+
−	
+
−	return PB_OK;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_pb_ReadRec
+
− 
+
− $Description:	Reads a record from the logical position index.  The record information
+
− 				will be returned in the data structure pointed to by record.  The 
+
−				T_PB_RECORD structure must be allocated by the user.
+
−
+
−				This function calls the ATB_mem_ReadRec function, with an additional
+
−				check to make sure no other commands are currently executing.
+
−
+
− $Returns:		PB_OK				Action completed OK.
+
− 				PB_BUSY				Failed, phonebook is busy.
+
−				PB_FILEREADFAIL		File read encountered an error
+
−				PB_RECDOESNOTEXIST	Tried to access a record that does not exist
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier
+
−				index_type		The index list from which the record is to be read
+
−				log_index		Logical index in the index list of the record to read
+
−				record			Structure in which to store record data
+
− 
+
−*******************************************************************************/
+
−
+
−PB_RET	ATB_pb_ReadRec(SHORT phonebook_id, T_PB_INDEX index_type, SHORT log_index, T_PB_RECORD *record)
+
−{
+
−	T_PB_DATA *data = ATB_hnd_GetPbData(phonebook_id);
+
−	PB_RET result;
+
−
+
−	tracefunction("ATB_pb_ReadRec");
+
−
+
−	/* Ensure that phonebook exists */
+
−	if (!data)
+
−	{
+
−		trace("**ERROR** Phonebook does not exist");
+
−		return PB_BOOKDOESNOTEXIST;
+
−	}
+
−	
+
−	/* Make sure phonebook is not busy */
+
−	
+
−	if (ATB_pb_Status(phonebook_id)==PB_BUSY)
+
−	{
+
−		trace("* ERROR * - Phonebook is busy");
+
−		result = PB_BUSY;
+
−	}
+
−	else
+
−	{
+
−		/* Read the record from cache or from file */
+
−		
+
−		result = ATB_mem_ReadRec(phonebook_id, index_type, log_index, record);
+
−	}
+
−
+
−	/* Send success/failure info to the GI */
+
−	
+
−	if (result==PB_OK)
+
−		GI_pb_OK(phonebook_id, PB_READREC, NULL);
+
−	else if (result!=PB_EXCT)
+
−		GI_pb_Error(phonebook_id, PB_READREC, result);
+
−
+
−	/* Close any open file */
+
−	
+
−	FS_pb_Finished(phonebook_id);
+
−	
+
−	return result;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_pb_WriteRec
+
− 
+
− $Description:	Writes a record to the logical position index.  If the index is
+
− 				PB_NEW_RECORD, a new record is added, otherwise the previous
+
− 				record at that position is overwritten. The name and number index lists
+
− 				will be updated with the new entry in the appropriate place in each.
+
−				GI_pb_OK will be called to confirm that the write completed successfully,
+
−				otherwise GI_pb_Error will be called with an error code.
+
−				Since the order of the records may change due to sorting, GI_pb_OK
+
−				will receive a pointer to an integer new_log_index, which will store the
+
−				new position of the record in the chosen index list.  This is allocated
+
−				by and will be destroyed by the phonebook, so must be copied by the
+
−				GI before function return.
+
−
+
− $Returns:		PB_OK				Action completed OK.
+
−				PB_EXCT				Action currently executing, callback awaited.
+
−									GI_pb_OK will be called if successful,
+
−									GI_pb_Error otherwise.
+
−									GI_pb_OK will receive a pointer to the following:
+
−									SHORT new_log_index - The new position of the
+
− 									record in the chosen index list
+
− 				PB_BUSY				Failed, phonebook is busy.
+
−				PB_FILEWRITEFAIL	File write encountered an error
+
−				PB_RECDOESNOTEXIST	(Overwriting only) Tried to access a record that
+
−									does not exist
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier
+
−				index_type		The index list of the record to write
+
−				log_index		Logical index in the index list of the record to write
+
−				record			Pointer to record data to write to phonebook
+
−								(allocated by caller)
+
− 
+
−*******************************************************************************/
+
−/*a0393213 warnings removal-second parameter type changed from T_PB_TYPE to T_PB_INDEX*/
+
−PB_RET ATB_pb_WriteRec(SHORT phonebook_id, T_PB_INDEX index_type, SHORT log_index, T_PB_RECORD *record)
+
−{
+
−	T_PB_DATA *data = ATB_hnd_GetPbData(phonebook_id);
+
−	SHORT phys_index;
+
−
+
−	tracefunction("ATB_pb_WriteRec");
+
−
+
−	/* Ensure that phonebook exists */
+
−	if (!data)
+
−	{
+
−		trace("**ERROR** Phonebook does not exist");
+
−		return PB_BOOKDOESNOTEXIST;
+
−	}
+
−	
+
−	/* Make sure phonebook is not busy */
+
−	
+
−	if (ATB_pb_Status(phonebook_id)==PB_BUSY)
+
−	{
+
−		trace("* ERROR * - Phonebook is busy");
+
−		GI_pb_Error(phonebook_id, PB_WRITEREC, PB_BUSY);
+
−		return PB_BUSY;
+
−	}
+
−
+
−	/* Are we adding a new record, or overwriting an old one? */
+
−	
+
−	if (log_index==PB_NEW_RECORD)
+
−	{
+
−		/* Is phonebook full? */
+
−
+
−		if (data->records_used==data->records_max)
+
−		{
+
−			GI_pb_Error(phonebook_id, PB_WRITEREC, PB_BOOKFULL);
+
−			return PB_BOOKFULL;
+
−		}
+
−		
+
−		/* Find an empty physical record */
+
−		for (phys_index=0; phys_index<data->records_max; phys_index++)
+
−		{
+
−			if (data->in_memory[phys_index]==PB_EMPTY_RECORD)
+
−				break;
+
−		}
+
−	}
+
−	else
+
−	{
+
−		/* Check that record exists */
+
−
+
−		if (log_index<0
+
−			|| (log_index>=data->records_used && (index_type==INDEX_NAME || index_type==INDEX_NUMBER))
+
−			|| (index_type==INDEX_SEARCH && log_index>data->search_results)
+
−			|| (index_type==INDEX_PHYSICAL && log_index>data->records_max))
+
−		{
+
−			GI_pb_Error(phonebook_id, PB_WRITEREC, PB_RECDOESNOTEXIST);
+
−			return PB_RECDOESNOTEXIST;
+
−		}
+
−		
+
−		phys_index = ATB_index_GetPhysIndex(phonebook_id, index_type, log_index);
+
−	}
+
−
+
−	/* Set up command */
+
−	
+
−	data->command_id 	= PB_WRITEREC;
+
−	data->status		= PB_STATUS_INIT;
+
−
+
−	data->param.WriteRec.log_index = log_index;
+
−	data->param.WriteRec.index_type = index_type;
+
−	data->param.WriteRec.phys_index = phys_index;
+
−	data->param.WriteRec.record = record;
+
−	
+
−	return ATB_status_WriteRec(phonebook_id);
+
−}
+
−
+
−/* Status function for WriteRec */
+
−
+
−PB_RET ATB_status_WriteRec(SHORT phonebook_id)
+
−{
+
−	T_PB_DATA		*data		= ATB_hnd_GetPbData(phonebook_id);
+
−	T_PB_WRITEREC	*WriteRec	= &data->param.WriteRec;
+
−	SHORT				blocking;
+
−	PB_RET			result=PB_ERROR;
+
−	SHORT				name_log_index;
+
−	SHORT				number_log_index;
+
−	SHORT				*log_index_return;
+
−
+
−	blocking = TRUE;
+
−	while (blocking)
+
−	{
+
−		switch(data->status)
+
−		{
+
−			case PB_STATUS_INIT:
+
−				result = FS_pb_WriteRec(phonebook_id, WriteRec->phys_index, WriteRec->record);
+
−				
+
−				/* Select next state */
+
−				
+
−				data->status = PB_STATUS_COMPLETE;
+
−				
+
−				/* Allow exit from function */
+
−				
+
−				if (result!=PB_OK)
+
−					blocking = FALSE;
+
−				break;
+
−
+
−			case PB_STATUS_COMPLETE:
+
−
+
−				if (WriteRec->log_index!=PB_NEW_RECORD)
+
−				{
+
−					name_log_index = ATB_index_GetLogIndex(phonebook_id, INDEX_NAME, WriteRec->phys_index);
+
−					ATB_index_RemoveRec(phonebook_id, INDEX_NAME, name_log_index);
+
−					number_log_index = ATB_index_GetLogIndex(phonebook_id, INDEX_NUMBER, WriteRec->phys_index);
+
−					ATB_index_RemoveRec(phonebook_id, INDEX_NUMBER, number_log_index);
+
−					data->records_used--;
+
−				}
+
−
+
−				/* Indicate that record is new, then add to the cache */
+
−				
+
−				data->in_memory[WriteRec->phys_index] = 0;
+
−				ATB_mem_UpdateCache(phonebook_id, WriteRec->phys_index, WriteRec->record); 
+
−
+
−				/* Add the record to the index lists */
+
−				
+
−				ATB_index_AddRec(phonebook_id, INDEX_NAME, WriteRec->phys_index, WriteRec->record, &name_log_index);
+
−				ATB_index_AddRec(phonebook_id, INDEX_NUMBER, WriteRec->phys_index, WriteRec->record, &number_log_index);
+
−				data->records_used++;
+
−				
+
−				blocking = FALSE;
+
−
+
−				/* Close any open file */
+
−				
+
−				FS_pb_Finished(phonebook_id);
+
−				FS_pb_WriteTables(phonebook_id, data->records_used, data->name_table, data->number_table);
+
−	
+
−				/* Notify the GI of success */
+
−				log_index_return = NULL;
+
−				if (WriteRec->index_type==INDEX_NAME)
+
−					log_index_return = &name_log_index;
+
−				if (WriteRec->index_type==INDEX_NUMBER)
+
−					log_index_return = &number_log_index;
+
−				
+
−				GI_pb_OK(phonebook_id, data->command_id, log_index_return);
+
−				result = PB_OK;
+
−				data->status = PB_STATUS_NONE;
+
−				break;
+
−		}
+
−	}
+
−
+
−	/* Report any errors to the GI */
+
−	
+
−	if (result!=PB_OK && result!=PB_EXCT)
+
−	{
+
−		GI_pb_Error(phonebook_id, PB_WRITEREC, result);	
+
−	}
+
−	
+
−	return result;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_pb_DeleteRec
+
− 
+
− $Description:	Deletes a record at a logical position index.
+
−				GI_pb_OK will be called to confirm that the delete completed successfully,
+
−				otherwise GI_pb_Error will be called with an error code.
+
−
+
− $Returns:		PB_OK				Action completed OK.
+
−				PB_EXCT				Action currently executing, callback awaited.
+
−									GI_pb_OK will be called if successful,
+
−									GI_pb_Error otherwise.
+
−				PB_BUSY				Failed, phonebook is busy.
+
−				PB_FILEWRITEFAIL	File write encountered an error
+
−				PB_RECDOESNOTEXIST	Tried to access a record that does not exist
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier
+
−				index_type		The index list of the record to delete
+
−				log_index		Logical index in the index list of the record to delete
+
−
+
−*******************************************************************************/
+
−
+
−PB_RET ATB_pb_DeleteRec(SHORT phonebook_id, T_PB_INDEX index_type, SHORT log_index)
+
−{
+
−	T_PB_DATA *data = ATB_hnd_GetPbData(phonebook_id);
+
−
+
−	tracefunction("ATB_pb_DeleteRec");
+
−	
+
−	/* Ensure that phonebook exists */
+
−	if (!data)
+
−	{
+
−		trace("**ERROR** Phonebook does not exist");
+
−		return PB_BOOKDOESNOTEXIST;
+
−	}
+
−
+
−	/* Make sure phonebook is not busy */
+
−	
+
−	if (ATB_pb_Status(phonebook_id)==PB_BUSY)
+
−	{
+
−		trace("* ERROR * - Phonebook is busy");
+
−		GI_pb_Error(phonebook_id, PB_DELETEREC, PB_BUSY);
+
−		return PB_BUSY;
+
−	}
+
−	
+
−	/* Check that record exists */
+
−
+
−	if (log_index<0
+
−		|| (log_index>=data->records_used && (index_type==INDEX_NAME || index_type==INDEX_NUMBER))
+
−		|| (index_type==INDEX_SEARCH && log_index>data->search_results)
+
−		|| (index_type==INDEX_PHYSICAL && log_index>data->records_max))
+
−	{
+
−		GI_pb_Error(phonebook_id, PB_DELETEREC, PB_RECDOESNOTEXIST);
+
−		return PB_RECDOESNOTEXIST;
+
−	}
+
−	
+
−	/* Set up the command */
+
−	
+
−	data->command_id = PB_DELETEREC;
+
−	data->status	= PB_STATUS_INIT;
+
−
+
−	data->param.DeleteRec.log_index = log_index;
+
−	data->param.DeleteRec.index_type = index_type;
+
−	data->param.DeleteRec.phys_index = ATB_index_GetPhysIndex(phonebook_id, index_type, log_index);
+
−	
+
−	return ATB_status_DeleteRec(phonebook_id);
+
−}
+
−
+
−/* Status function for DeleteRec */
+
−
+
−PB_RET ATB_status_DeleteRec(SHORT phonebook_id)
+
−{
+
−	T_PB_DATA		*data		= ATB_hnd_GetPbData(phonebook_id);
+
−	T_PB_DELETEREC	*DeleteRec	= &data->param.DeleteRec;
+
−	SHORT				blocking;
+
−	PB_RET			result=PB_ERROR;
+
−	SHORT				name_log_index;
+
−	SHORT				number_log_index;
+
−
+
−	blocking = TRUE;
+
−	while (blocking)
+
−	{
+
−		switch(data->status)
+
−		{
+
−			case PB_STATUS_INIT:
+
−				result = FS_pb_DeleteRec(phonebook_id, DeleteRec->phys_index);
+
−				
+
−				/* Select next state */
+
−				
+
−				data->status = PB_STATUS_COMPLETE;
+
−				
+
−				/* Allow exit from function */
+
−				
+
−				if (result!=PB_OK)
+
−					blocking = FALSE;
+
−				break;
+
−
+
−			case PB_STATUS_COMPLETE:
+
−				name_log_index = ATB_index_GetLogIndex(phonebook_id, INDEX_NAME, DeleteRec->phys_index);
+
−				ATB_index_RemoveRec(phonebook_id, INDEX_NAME, name_log_index);
+
−				number_log_index = ATB_index_GetLogIndex(phonebook_id, INDEX_NUMBER, DeleteRec->phys_index);
+
−				ATB_index_RemoveRec(phonebook_id, INDEX_NUMBER, number_log_index);
+
−				data->records_used--;
+
−				data->in_memory[DeleteRec->phys_index] = -1;
+
−
+
−				// Jan 18, 2004 REF: CRR MMI-SPR-25332 xnkulkar
+
−    				// Description: Moving entries from Sim Card to phone memory fails. 
+
−    				// Solution: When entries are moved, corresponding updations are done in cache as well.
+
−				if(data->cache[DeleteRec->phys_index]!=NULL)
+
−				{
+
−             				ATB_pb_FreeRec(phonebook_id, data->cache[DeleteRec->phys_index]);
+
−	 				data->cache[DeleteRec->phys_index]=NULL;
+
−	 				data->cache_size--;
+
−				}
+
−
+
−				/* Close any open file */
+
−	
+
−				FS_pb_Finished(phonebook_id);
+
−				FS_pb_WriteTables(phonebook_id, data->records_used, data->name_table, data->number_table);
+
−					
+
−				blocking = FALSE;
+
−				
+
−				/* Notify the GI of success */
+
−
+
−				GI_pb_OK(phonebook_id, data->command_id, NULL);
+
−				result = PB_OK;
+
−				data->status = PB_STATUS_NONE;
+
−				break;
+
−		}
+
−	}
+
−
+
−	/* Report any errors to the GI */
+
−	
+
−	if (result!=PB_OK && result!=PB_EXCT)
+
−	{
+
−		GI_pb_Error(phonebook_id, PB_DELETEREC, result);	
+
−	}
+
−	
+
−	return result;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_pb_Find
+
− 
+
− $Description:	Find the nearest match to the supplied record.  Only the index_type
+
− 				specified will be considered: if the index_type is INDEX_NAME, then the
+
− 				name only will be matched; if INDEX_NUMBER, then just the number.
+
−				The new_log_index parameter should be a pointer to a user allocated
+
−				integer.  This will return the logical index of the closest match in the
+
−				index list specified.  This index either corresponds to a perfect match,
+
−				or to the record that would appear just after the provided record in the
+
−				list.  For example, if the list consisted of record 0, Alice and record 1,
+
−				Carol, then a search for Bob would return 1.  A search for a record
+
−				that would occur before the first record always returns 0.  A search for
+
−				a record that would occur after the last record returns the index of the
+
−				last record +1.
+
−				The "match" parameter should be a pointer to a user allocated variable
+
−				of type T_PB_MATCH.  This returns information about how closely the
+
−				found entry matches the record.  In the example above, a search for
+
−				Bob would return 1 and MATCH_NONE; a search for Ca would return 1
+
−				and MATCH_START, and a search for Carol would return 1 and
+
−				MATCH_EXACT. Rarely, match may be MATCH_FRAGMENT: this can be
+
−				considered equivalent to MATCH_NONE in this context.
+
−
+
− $Returns:		PB_OK				Action completed OK.
+
− 				PB_BUSY				Failed, phonebook is busy.
+
−				PB_FILEREADFAIL		File read encountered an error
+
−				PB_RECDOESNOTEXIST	Tried to access a record that does not exist
+
−									(should never happen)
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier
+
−				index_type		The index_type of the provided record that is to be
+
−								searched for, and the index list that the resulting
+
−								new_log_index pertains to
+
−				record			The record whose index_type is to be matched
+
−				new_log_index	Returns with the logical index of the closest matching
+
−								record
+
−				match			Specifies how good the resulting match was
+
−								(MATCH_NONE, MATCH_START, MATCH_FRAGMENT
+
−								or MATCH_EXACT).
+
− 
+
−*******************************************************************************/
+
−
+
−
+
−PB_RET ATB_pb_Find (SHORT phonebook_id, T_PB_INDEX index_type, T_PB_RECORD *record, SHORT *new_log_index, T_PB_MATCH *match)
+
−{
+
−	PB_RET result;
+
−
+
−	tracefunction("ATB_pb_Find");
+
−	
+
−	result = ATB_index_Find(phonebook_id, index_type, record, new_log_index, match);
+
−
+
−	/* Close any open file */
+
−	
+
−	FS_pb_Finished(phonebook_id);
+
−		
+
−	/* Send success/failure info to the GI */
+
−	
+
−	if (result==PB_OK)
+
−		GI_pb_OK(phonebook_id, PB_FIND, NULL);
+
−	else if (result!=PB_EXCT)
+
−		GI_pb_Error(phonebook_id, PB_FIND, result);
+
−
+
−	return result;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_pb_ReadRecList
+
− 
+
− $Description:	Fetches record information of sequential records in an index list, starting
+
− 				at logical record start_log_index and fetching recs_count records in total.
+
− 				The information will be stored in the caller allocated array of records
+
− 				provided.
+
−
+
− $Returns:		PB_OK				Action completed OK.
+
−				PB_BUSY				Failed, phonebook is busy.
+
−				PB_FILEREADFAIL		File read encountered an error
+
−				PB_RECDOESNOTEXIST	Tried to access a record that does not exist
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier
+
−				index_type		The index list to use
+
−				start_log_index	Logical index in the index list of the first record to
+
−								read
+
−				recs_count		Total number of sequential records to read. 
+
−				record			Array of entries in which to store the fetched records.
+
−								The array must be recs_count in size. (Caller allocated).
+
− 
+
−*******************************************************************************/
+
−
+
−PB_RET ATB_pb_ReadRecList(SHORT phonebook_id, T_PB_INDEX index_type, SHORT start_log_index, SHORT num_recs, T_PB_LIST *list)
+
−{
+
−	PB_RET result;
+
−	SHORT log_index;
+
−
+
−	tracefunction("ATB_pb_ReadRecList");
+
−	
+
−	list->records_used = 0;
+
−
+
−	/* Make sure phonebook is not busy */
+
−	
+
−	if (ATB_pb_Status(phonebook_id)==PB_BUSY)
+
−	{
+
−		trace("* ERROR * - Phonebook is busy");
+
−			/* Report any errors to the GI */
+
−		GI_pb_Error(phonebook_id, PB_READRECLIST, PB_BUSY);	
+
−		return PB_BUSY;
+
−	}
+
−
+
−	/* Read in list of records */
+
−	
+
−	for (log_index = start_log_index; log_index<start_log_index+num_recs && log_index<list->records_max; log_index++)
+
−	{
+
−		result = ATB_mem_ReadRec(phonebook_id, index_type, log_index, &list->record[log_index-start_log_index]);
+
−		if (result!=PB_OK)
+
−			break;
+
−		list->records_used++;
+
−	}
+
−
+
−	/* Close any open file */
+
−	
+
−	FS_pb_Finished(phonebook_id);
+
−	
+
−	/* Send success/failure info to the GI */
+
−	
+
−	if (result==PB_OK)
+
−		GI_pb_OK(phonebook_id, PB_READRECLIST, NULL);
+
−	else if (result!=PB_EXCT)
+
−		GI_pb_Error(phonebook_id, PB_READRECLIST, result);
+
−	
+
−	return result;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_pb_Search
+
− 
+
− $Description:	Searches every record in the index list for a fragment.  The index list
+
− 				must be either INDEX_NAME or INDEX_NUMBER.  If it is INDEX_NAME,
+
− 				then a name fragment will be searched for; if it is INDEX_NUMBER,
+
− 				a number fragment will be searched for.
+
−
+
−				The results are stored in an index list.  They may be accessed by
+
−				using the normal read and write functions, using the index type
+
−				INDEX_SEARCH.  The size of the search list is returned in the variable
+
−				recs_count.
+
−
+
− $Returns:		PB_OK				Action completed OK.
+
−				PB_BUSY				Failed, phonebook is busy.
+
−				PB_FILEREADFAIL		File read encountered an error
+
−				PB_RECDOESNOTEXIST	Tried to access a record that does not exist
+
−				(should never happen)
+
−
+
− $Arguments:	phonebook_id The phonebook identifier
+
−				index_type	The index list to use
+
−				record		Record containing the fragment to search for
+
−				recs_count	Pointer to an int (user allocated) in which will be returned
+
−							the number of search results. 
+
−
+
− 
+
−*******************************************************************************/
+
−
+
−PB_RET ATB_pb_Search(SHORT phonebook_id, T_PB_INDEX index_type, T_PB_RECORD *record, SHORT *recs_count)
+
−{
+
−	T_PB_DATA *data = ATB_hnd_GetPbData(phonebook_id);
+
−	PB_RET result;
+
−	SHORT count = 0;
+
−	SHORT log_index;
+
−	T_PB_MATCH match;
+
−	T_PB_RECORD *cur_record;
+
−
+
−	/* Ensure that phonebook exists */
+
−	if (!data)
+
−	{
+
−		trace("**ERROR** Phonebook does not exist");
+
−		return PB_BOOKDOESNOTEXIST;
+
−	}
+
−
+
−	/* Allocate record for temporary use */
+
−	
+
−	cur_record = ATB_pb_AllocRec(phonebook_id);
+
−		
+
−	/* Make sure phonebook is not busy */
+
−	
+
−	if (ATB_pb_Status(phonebook_id)==PB_BUSY)
+
−	{
+
−		trace("* ERROR * - Phonebook is busy");
+
−		GI_pb_Error(phonebook_id, PB_SEARCH, PB_BUSY);	
+
−		return PB_BUSY;
+
−	}
+
−	
+
−	/* Make sure we're searching a valid index type */
+
−
+
−	if (index_type==INDEX_PHYSICAL || index_type==INDEX_SEARCH)
+
−	{
+
−		GI_pb_Error(phonebook_id, PB_SEARCH, PB_INDEXINVALID);	
+
−		return PB_INDEXINVALID;
+
−	}
+
−	
+
−	for (log_index=0; log_index<data->records_used; log_index++)
+
−	{
+
−		result = ATB_mem_ReadRec(phonebook_id, index_type, log_index, cur_record);
+
−		if (result!=PB_OK)
+
−			break;
+
−			
+
−		match = ATB_index_Match(record, cur_record, index_type);
+
−		
+
−		if (match==MATCH_EXACT || match==MATCH_START || match==MATCH_FRAGMENT)
+
−		{
+
−			data->search_table[count] = ATB_index_GetPhysIndex(phonebook_id, index_type, log_index);
+
−			count++;
+
−		}
+
−	}
+
−
+
−	data->search_results = count;
+
−	*recs_count = count;
+
−
+
−	/* Free allocated record */
+
−	
+
−	ATB_pb_FreeRec(phonebook_id, cur_record);
+
−
+
−	/* Close any open file */
+
−	
+
−	FS_pb_Finished(phonebook_id);
+
−	
+
−	/* Send success/failure info to the GI */
+
−	
+
−	if (result==PB_OK)
+
−		GI_pb_OK(phonebook_id, PB_SEARCH, NULL);
+
−	else if (result!=PB_EXCT)
+
−		GI_pb_Error(phonebook_id, PB_SEARCH, result);
+
−
+
−	return result;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_pb_ConvIndex
+
− 
+
− $Description:	Returns the index in table dest_index_type corresponding to the index
+
− 				in table src_index_type.
+
− 
+
− $Returns:		PB_OK			Action completed OK.
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier.
+
−				index_type	The index table of the original index.
+
−				log_index		The original logical index.
+
−				new_index_type	The index table required.
+
−				new_log_index	Pointer to where the new logical index will be stored
+
−				
+
−*******************************************************************************/
+
−
+
−PB_RET ATB_pb_ConvIndex(SHORT phonebook_id, T_PB_INDEX index_type, SHORT log_index,
+
−	T_PB_INDEX new_index_type, SHORT *new_log_index)
+
−{
+
−	T_PB_DATA *data = ATB_hnd_GetPbData(phonebook_id);
+
−	SHORT phys_index;
+
−
+
−	/* Ensure that phonebook exists */
+
−	if (!data)
+
−	{
+
−		trace("**ERROR** Phonebook does not exist");
+
−		return PB_BOOKDOESNOTEXIST;
+
−	}
+
−	
+
−	if (index_type==new_index_type)
+
−	{
+
−		*new_log_index = log_index;
+
−	}
+
−	else
+
−	{	
+
−		phys_index = ATB_index_GetPhysIndex(phonebook_id, index_type, log_index);
+
−		*new_log_index = ATB_index_GetLogIndex(phonebook_id, new_index_type, phys_index);
+
−	}
+
−	
+
−	return PB_OK;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_pb_CharToBCD
+
−
+
− $Description:	Converts an ascii string of digits into BCD form, with 4 bits representing
+
− 				each digit.
+
− 
+
− $Returns:		None
+
−
+
− $Arguments:	src 	- source string (ascii)
+
− 				dest	- destination string for BCD digits
+
− 
+
−*******************************************************************************/
+
−
+
−void ATB_pb_CharToBCD(UBYTE *dest, char *src, int max_len)
+
−{
+
−	UBYTE srcIndex = 0;
+
−	UBYTE destIndex = 0;
+
−	BOOL leftbits = TRUE;														/* Left or right nibble */
+
−	UBYTE digit = 0;
+
−  //add "*" "#" in number by Peng Hou on 19/06/2006 begin	
+
−    while (digit!=0xF && srcIndex<max_len)
+
−	{
+
−		if (src[srcIndex]==NULL)
+
−			digit = 0xF;														/* 0xF terminates BCD */
+
−	   else
+
−		{
+
−            switch ( src[srcIndex] )
+
−			{
+
−               case '0':
+
−               case '1':
+
−               case '2':
+
−               case '3':
+
−               case '4':
+
−               case '5':
+
−               case '6':
+
−               case '7':
+
−               case '8':
+
−               case '9':
+
−                digit = src[srcIndex]-'0';	
+
−               break;
+
−
+
−               case '*':
+
−                 digit = 0x0a;
+
−               break;
+
−
+
−              case '#':
+
−                 digit = 0x0b;
+
−              break;
+
−
+
−              case 'p':
+
−              case 'P':
+
−                 digit = 0x0c;
+
−              break;
+
−
+
−              case 'w':
+
−              case 'W':
+
−                 digit = 0x0d;
+
−              break;
+
−
+
−              case 'E':
+
−                 digit = 0x0e;
+
−               break;
+
−
+
−             default:
+
−               continue;
+
−			}
+
−		}
+
−	//add "*" "#" in number by Peng Hou on 19/06/2006 end		
+
−			
+
−			//	digit = src[srcIndex]-'0';											/* The digit, 0 to 9. */
+
−
+
−
+
−		if (leftbits)
+
−		{
+
−			dest[destIndex] = digit;
+
−			leftbits = FALSE;
+
−		}
+
−		else
+
−		{
+
−			dest[destIndex] |= digit<<4;										/* *16 shifts right 4 bits */
+
−			leftbits = TRUE;
+
−			destIndex++;
+
−		}
+
−		srcIndex++;
+
−	} 
+
−	
+
−	return;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_pb_BCDToChar
+
−
+
− $Description:	Converts a BCD string to ascii digits
+
− 
+
− $Returns:		None
+
−
+
− $Arguments:	src 	- source string (BCD)
+
− 				dest	- destination string for ascii digits
+
− 
+
−*******************************************************************************/
+
−
+
−void ATB_pb_BCDToChar(char *dest, UBYTE *src, int max_len)
+
−{
+
−	SHORT numIndex = 0;
+
−	UBYTE digit = 0xF; //dummy
+
− //add "*" "#" in number by Peng Hou on 19/06/2006 begin
+
−	while (digit!=NULL && numIndex<max_len)
+
−	{
+
−		/*HELLO!*/
+
−		digit = ATB_num_Digit(src, numIndex);
+
−
+
−		if (digit==0xF)
+
−			digit = NULL;
+
−		else
+
−		{
+
−		      switch ( digit )
+
−              {
+
−                 case 0:
+
−                 case 1:
+
−                 case 2:
+
−                 case 3:
+
−                 case 4:
+
−                 case 5:
+
−                 case 6:
+
−                 case 7:
+
−                 case 8:
+
−                 case 9:
+
−      	          {
+
−      	              digit+='0';
+
−		              dest[numIndex] = digit;
+
−		           }   
+
−		         break;
+
−
+
−                case 0x0a:
+
−                      dest[numIndex]='*';
+
−	            break;
+
−                case 0x0b:
+
−		              dest[numIndex]='#';
+
−     	        break;
+
−               case 0x0c:
+
−		              dest[numIndex]='P';
+
−     	       break;
+
−               case 0x0d:
+
−		              dest[numIndex]='W';
+
−     	       break;
+
−               case 0x0e:
+
−		               dest[numIndex] ='E';
+
−     	       break;
+
−               default:
+
−                       dest[numIndex] ='\0';
+
−  }
+
−
+
−}
+
−
+
−		//	digit+='0';
+
− //add "*" "#" in number by Peng Hou on 19/06/2006 end
+
−		numIndex++;
+
−	}
+
−
+
−	return;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_pb_AllocRec
+
− 
+
− $Description:	Allocates memory for a record
+
−
+
− $Returns:		
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier
+
− 
+
−*******************************************************************************/
+
−
+
−T_PB_RECORD *ATB_pb_AllocRec(SHORT phonebook_id)
+
−{
+
−	T_PB_DATA *data = ATB_hnd_GetPbData(phonebook_id);
+
−	T_PB_RECORD *record;
+
−	
+
−	record = (T_PB_RECORD *)GI_pb_MemAlloc(sizeof(T_PB_RECORD));
+
−	
+
−	record->alpha.data = (USHORT *)GI_pb_MemAlloc(data->alpha_max*sizeof(USHORT));
+
−	record->number = (UBYTE *)GI_pb_MemAlloc(data->number_max/2);
+
−	if (data->ext_max>0)
+
−	{
+
−		record->ext_data = (UBYTE *)GI_pb_MemAlloc(data->ext_max);
+
−	}
+
−	else
+
−	{
+
−		record->ext_data = NULL;
+
−	}
+
−	record->ton_npi = 0;
+
−
+
−	return record;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_pb_FreeRec
+
− 
+
− $Description:	Frees memory allocated for a record
+
−
+
− $Returns:		
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier
+
− 				record			The record to destroy
+
− 
+
−*******************************************************************************/
+
−
+
−void ATB_pb_FreeRec(SHORT phonebook_id, T_PB_RECORD *record)
+
−{
+
−	T_PB_DATA *data = ATB_hnd_GetPbData(phonebook_id);
+
−
+
−	if (data->ext_max>0 && record->ext_data!=NULL)
+
−	{
+
−		GI_pb_MemFree((UBYTE *)record->ext_data, data->ext_max);
+
−	}
+
−	GI_pb_MemFree((UBYTE *)record->number, data->number_max/2);
+
−	GI_pb_MemFree((UBYTE *)record->alpha.data, data->alpha_max*sizeof(USHORT));
+
−
+
−	GI_pb_MemFree((UBYTE *)record, sizeof(T_PB_RECORD));
+
−	
+
−	return;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_pb_AllocRecList
+
− 
+
− $Description:	Allocates memory for a list of records
+
−
+
− $Returns:		
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier
+
− 				num_recs		The number of records to allocate
+
− 
+
−*******************************************************************************/
+
−
+
−T_PB_LIST *ATB_pb_AllocRecList(SHORT phonebook_id, SHORT num_recs)
+
−{
+
−	T_PB_DATA *data = ATB_hnd_GetPbData(phonebook_id);
+
−	T_PB_LIST *list;
+
−	SHORT rec_index;
+
−	
+
−	list = (T_PB_LIST *)GI_pb_MemAlloc(sizeof(T_PB_LIST));
+
−	list->records_max = num_recs;
+
−	list->records_used = 0;
+
−	list->record = (T_PB_RECORD *)GI_pb_MemAlloc(sizeof(T_PB_RECORD)*num_recs);
+
−	
+
−	for (rec_index=0; rec_index<num_recs; rec_index++)
+
−	{
+
−		list->record[rec_index].alpha.data = (USHORT *)GI_pb_MemAlloc(data->alpha_max*sizeof(USHORT));
+
−		list->record[rec_index].number = (UBYTE *)GI_pb_MemAlloc(data->number_max/2);
+
−		if (data->ext_max>0)
+
−		{
+
−			list->record[rec_index].ext_data = (UBYTE *)GI_pb_MemAlloc(data->ext_max);
+
−		}
+
−		else
+
−		{
+
−			list->record[rec_index].ext_data = NULL;
+
−		}
+
−	}
+
−
+
−	return list;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_pb_FreeRecList
+
− 
+
− $Description:	Frees memory allocated for a list of records
+
−
+
− $Returns:		
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier
+
− 				record			The records to destroy
+
− 				num_recs		Number of records in the list
+
− 
+
−*******************************************************************************/
+
−
+
−void ATB_pb_FreeRecList(SHORT phonebook_id, T_PB_LIST *list)
+
−{
+
−	T_PB_DATA *data = ATB_hnd_GetPbData(phonebook_id);
+
−	SHORT rec_index;
+
−	
+
−	for (rec_index=0; rec_index<list->records_max; rec_index++)
+
−	{
+
−		if (data->ext_max>0 && list->record[rec_index].ext_data!=NULL)
+
−		{
+
−			GI_pb_MemFree((UBYTE *)list->record[rec_index].ext_data, data->ext_max);
+
−		}
+
−		GI_pb_MemFree((UBYTE *)list->record[rec_index].number, data->number_max/2);
+
−		GI_pb_MemFree((UBYTE *)list->record[rec_index].alpha.data, data->alpha_max*sizeof(USHORT));
+
−	}
+
−
+
−	GI_pb_MemFree((UBYTE *)list->record, sizeof(T_PB_RECORD)*list->records_max);
+
−	GI_pb_MemFree((UBYTE *)list, sizeof(T_PB_LIST));
+
−
+
−	return;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_mem_CopyRec
+
− 
+
− $Description:	Copies a record from one location to another.  The destination should
+
− 				have memory allocated for its strings.
+
−
+
− $Returns:		
+
−
+
− $Arguments:	dest_record		The destination record
+
− 				src_record		The source record
+
− 
+
−*******************************************************************************/
+
−
+
−void	ATB_pb_CopyRec(SHORT phonebook_id, T_PB_RECORD *dest_record, T_PB_RECORD *src_record)
+
−{
+
−	T_PB_DATA *data = ATB_hnd_GetPbData(phonebook_id);
+
−	
+
−	dest_record->alpha.length = src_record->alpha.length;
+
−	dest_record->alpha.dcs = src_record->alpha.dcs;
+
−	memcpy((UBYTE *)dest_record->alpha.data, (UBYTE *)src_record->alpha.data, data->alpha_max*sizeof(USHORT));
+
−	memcpy(dest_record->number, src_record->number, data->number_max/2);
+
−	if (data->ext_max>0)
+
−	{
+
−		memcpy(dest_record->ext_data, src_record->ext_data, data->ext_max);
+
−	}
+
−	dest_record->ton_npi = src_record->ton_npi;
+
−	
+
−	return;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_pb_OK
+
− 
+
− $Description:	This function is called if the requested FS command executed successfully.
+
−
+
− $Returns:		None.
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier
+
− 
+
−*******************************************************************************/
+
−
+
−
+
−PB_RET ATB_pb_OK(SHORT phonebook_id)
+
−{
+
−	T_PB_DATA *data = ATB_hnd_GetPbData(phonebook_id);
+
−	PB_RET result=PB_ERROR;
+
−
+
−	switch(data->command_id)
+
−	{
+
−		case PB_INITIALISE:
+
−			result = ATB_status_Initialise(phonebook_id);
+
−			break;
+
−		case PB_WRITEREC:
+
−			result = ATB_status_WriteRec(phonebook_id);
+
−			break;
+
−		case PB_DELETEREC:
+
−			result = ATB_status_DeleteRec(phonebook_id);
+
−			break;
+
−	}
+
−
+
−	return result;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_pb_Error
+
− 
+
− $Description:	This function is called if an error was returned while executing the
+
− 				requested command.
+
−
+
− $Returns:		None.
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier
+
−				error_id		Identifies the error that occurred.
+
−
+
−*******************************************************************************/
+
−
+
−void ATB_pb_Error(SHORT phonebook_id, SHORT error_id)
+
−{
+
−	T_PB_DATA *data = ATB_hnd_GetPbData(phonebook_id);
+
−
+
−	/* Forward the error report to the GI */
+
−
+
−	GI_pb_Error(phonebook_id, data->command_id, error_id);
+
−	data->status = PB_STATUS_NONE;
+
−	
+
−	return;
+
−}
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_index_GetTable
+
− 
+
− $Description:	Returns a pointer to the index table specified by the index_type
+
−
+
− $Returns:		None.
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier
+
−				index_type		The index table required.
+
−
+
−*******************************************************************************/
+
−
+
−SHORT * ATB_index_GetTable(SHORT phonebook_id, T_PB_INDEX index_type)
+
−{
+
−	T_PB_DATA *data = ATB_hnd_GetPbData(phonebook_id);
+
−	SHORT *table = NULL;
+
−	
+
−	switch(index_type)
+
−	{
+
−		case INDEX_NAME:
+
−			table = data->name_table;
+
−			break;
+
−		case INDEX_NUMBER:
+
−			table = data->number_table;
+
−			break;
+
−		case INDEX_SEARCH:
+
−			table = data->search_table;
+
−			break;
+
−		default:
+
−			table = GI_pb_GetTable(index_type);
+
−			break;
+
−	}
+
−
+
−	return table;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_index_Find
+
− 
+
− $Description:	Find the nearest match to the supplied record.  See ATB_pb_Find for
+
− 				more information.
+
−
+
− $Returns:		PB_OK				Action completed OK.
+
− 				PB_BUSY				Failed, phonebook is busy.
+
−				PB_FILEREADFAIL		File read encountered an error
+
−				PB_RECDOESNOTEXIST	Tried to access a record that does not exist
+
−									(should never happen)
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier
+
−				index_type		The index_type of the provided record that is to be
+
−								searched for, and the index list that the resulting
+
−								new_log_index pertains to
+
−				record			The record whose index_type is to be matched
+
−				new_log_index	Returns with the logical index of the closest matching
+
−								record
+
−				match			Specifies how good the resulting match was
+
−								(MATCH_NONE, MATCH_START, MATCH_FRAGMENT
+
−								or MATCH_EXACT).
+
− 
+
−*******************************************************************************/
+
−
+
−PB_RET ATB_index_Find (SHORT phonebook_id, T_PB_INDEX index_type, T_PB_RECORD *record, SHORT *new_log_index, T_PB_MATCH *match)
+
−{
+
−	T_PB_DATA *data = ATB_hnd_GetPbData(phonebook_id);
+
−	PB_RET result = PB_OK;
+
−	/*SHORT *table;*/ /*a0393213 warning removal-variable set but not used*/
+
−	SHORT lower;
+
−	SHORT upper;
+
−	SHORT middle;
+
−	T_PB_RECORD *comp_record;
+
−	T_PB_COMPARE compare;
+
−	UBYTE searching;
+
−	
+
−	/* Ensure that phonebook exists */
+
−	if (!data)
+
−	{
+
−		trace("**ERROR** Phonebook does not exist");
+
−		return PB_BOOKDOESNOTEXIST;
+
−	}
+
−
+
−	/* Allocate record for comparison */
+
−
+
−	comp_record = ATB_pb_AllocRec(phonebook_id);
+
−	
+
−	/* Make sure we're searching a valid index type */
+
−
+
−	if (index_type==INDEX_PHYSICAL || index_type==INDEX_SEARCH)
+
−	{
+
−		GI_pb_Error(phonebook_id, PB_FIND, PB_INDEXINVALID);	
+
−		return PB_INDEXINVALID;
+
−	}
+
−	
+
−	/*table = ATB_index_GetTable(phonebook_id, index_type);*//*a0393213 warning removal-variable set but not used*/
+
−
+
−	/* The initial upper and lower bounds are the bounds of the array */
+
−	lower = 0;
+
−	upper = data->records_used-1;
+
−
+
−	searching = TRUE;
+
−
+
−	/* If the list is empty, insert at 0 */
+
−	
+
−	if (data->records_used==0)
+
−	{
+
−		middle = 0;
+
−		searching = FALSE;
+
−	}
+
−	
+
−	while (searching)
+
−	{
+
−		/* Compare our record with the middle element of the partition */
+
−
+
−		middle = (lower+upper)/2;
+
−
+
−		result = ATB_mem_ReadRec(phonebook_id, index_type, middle, comp_record);
+
−		
+
−		if (result!=PB_OK)
+
−			break;
+
−			
+
−		compare = ATB_index_Compare(record, comp_record, index_type);
+
−
+
−		switch(compare)
+
−		{
+
−			case COMPARE_IDENTICAL:
+
−				/* We've found a match; stop searching */
+
−				searching = FALSE;
+
−				break;
+
−				
+
−			case COMPARE_FIRSTBEFORE:
+
−				if (middle==lower)
+
−				{
+
−					/* The partition is a single element, so stop here. */
+
−					searching = FALSE;
+
−				}
+
−				else
+
−				{
+
−					/* Our record comes before the middle element;
+
−					 * redefine the partiton */
+
−					upper = middle - 1;
+
−				}
+
−				break;
+
−				
+
−			case COMPARE_FIRSTAFTER:
+
−				if (middle==upper)
+
−				{
+
−				/* The partition is a single element, so stop here.  The record
+
−				 * we need is the record after this one. */
+
−					middle++;
+
−					searching = FALSE;
+
−				}
+
−				else
+
−				{
+
−					/* Our record comes after the middle element;
+
−					 * redefine the partiton */
+
−					lower = middle+1;
+
−				}
+
−				break;
+
−		}
+
−	}	
+
−
+
−	/* Store our results */
+
−	
+
−	if (new_log_index)
+
−		*new_log_index = middle;
+
−
+
−	if (match)
+
−	{
+
−		ATB_mem_ReadRec(phonebook_id, index_type, middle, comp_record);
+
−		*match = ATB_index_Match(record, comp_record, index_type);
+
−	}
+
−
+
−	/* Free allocated record */
+
−
+
−	ATB_pb_FreeRec(phonebook_id, comp_record);
+
−
+
−	/* Send success/failure info to the GI */
+
−	
+
−	if (result==PB_OK)
+
−		GI_pb_OK(phonebook_id, PB_FIND, NULL);
+
−	else if (result!=PB_EXCT)
+
−		GI_pb_Error(phonebook_id, PB_FIND, result);
+
−
+
−	return result;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_index_GetPhysIndex
+
− 
+
− $Description:	Returns the physical index corresponding to the given logical index, in
+
− 				the index table specified by the index_type.
+
−
+
− $Returns:		None.
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier.
+
−				index_type		The index table required.
+
−				log_index		The logical index.
+
−
+
−*******************************************************************************/
+
−
+
−SHORT ATB_index_GetPhysIndex(SHORT phonebook_id, T_PB_INDEX index_type, SHORT log_index)
+
−{
+
−	T_PB_DATA *data = ATB_hnd_GetPbData(phonebook_id);
+
−	SHORT phys_index=-1;
+
−	SHORT *table;
+
−
+
−	switch(index_type)
+
−	{
+
−		case INDEX_PHYSICAL:
+
−			phys_index = log_index;
+
−			break;
+
−		case INDEX_NAME:
+
−		case INDEX_NUMBER:
+
−		case INDEX_SEARCH:
+
−			table = ATB_index_GetTable(phonebook_id, index_type);
+
−			phys_index = table[log_index];
+
−			break;
+
−		default:
+
−			TRACE_ERROR("ATB_index_GetPhysIndex():Unknown index");
+
−			break;
+
−	}
+
−
+
−	return phys_index;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_index_GetLogIndex
+
− 
+
− $Description:	Provided with the physical index, finds the logical index of the record
+
− 				in the index table specified.
+
−
+
− $Returns:		None.
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier
+
−				index_type		The index table required.
+
−				phys_index		The logical index of the record to find
+
−
+
−*******************************************************************************/
+
−
+
−SHORT ATB_index_GetLogIndex(SHORT phonebook_id, T_PB_INDEX index_type, SHORT phys_index)
+
−{
+
−	T_PB_DATA *data = ATB_hnd_GetPbData(phonebook_id);
+
−	SHORT *table = ATB_index_GetTable(phonebook_id, index_type);
+
−	SHORT log_index;
+
−
+
−	if (index_type==INDEX_PHYSICAL)
+
−	{
+
−		log_index = phys_index;
+
−	}
+
−	else
+
−	{
+
−		for (log_index=0; log_index<data->records_used; log_index++)
+
−		{
+
−			if (table[log_index]==phys_index)
+
−				break;
+
−		}
+
−	}
+
−	
+
−	return log_index;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_index_AddRec
+
− 
+
− $Description:	Adds a record to an index list, sorting automatically as required.
+
−
+
− $Returns:		None.
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier
+
−				index_type		The index table required.
+
−				phys_index		The physical index of the record to add.
+
−				record			The record to add.
+
−				new_log_index	New logical index of record.
+
−
+
−*******************************************************************************/
+
−
+
−void ATB_index_AddRec(SHORT phonebook_id, T_PB_INDEX index_type, SHORT phys_index, T_PB_RECORD *record, SHORT *new_log_index)
+
−{
+
−	T_PB_DATA *data = ATB_hnd_GetPbData(phonebook_id);
+
−	SHORT *table = ATB_index_GetTable(phonebook_id, index_type);
+
−	SHORT log_index;
+
−	SHORT found_log_index;
+
−
+
−	ATB_index_Find(phonebook_id, index_type, record, &found_log_index, NULL);
+
−
+
−	/* Shift end of index table down */
+
−
+
−	for (log_index=data->records_used; log_index>found_log_index; log_index--)
+
−	{
+
−		table[log_index] = table[log_index-1];
+
−	}
+
−	
+
−	table[found_log_index] = phys_index;
+
−
+
−	if (new_log_index)
+
−		*new_log_index = found_log_index;
+
−	
+
−	return;
+
−}
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_index_RemoveRec
+
− 
+
− $Description:	Removes a record reference from an index list, sorting the index list
+
− 				appropriately.
+
−
+
− $Returns:		None.
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier
+
−				index_type		The index table required.
+
−				log_index		The logical index of the record to remove
+
−
+
−*******************************************************************************/
+
−
+
−void ATB_index_RemoveRec(SHORT phonebook_id, T_PB_INDEX index_type, SHORT log_index)
+
−{
+
−	T_PB_DATA *data = ATB_hnd_GetPbData(phonebook_id);
+
−	SHORT *table = ATB_index_GetTable(phonebook_id, index_type);
+
−	SHORT table_index;
+
−
+
−	for (table_index = log_index+1; table_index<data->records_used; table_index++)
+
−	{
+
−		table[table_index-1] = table[table_index];
+
−	}
+
−
+
−	return;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_index_Match
+
− 
+
− $Description:	This function attempts a match between two records based on the
+
− 				index_type specified in index_type.  It returns a value indicating
+
− 				whether there is no match (MATCH_NONE), a partial match
+
− 				(MAX_START), or an exact match (MATCH_EXACT).
+
−				The function GI_pb_Match is called first, to check whether there is
+
−				any user-specific matching required.  If not, then ATB_alpha_Match
+
−				is called for an alpha tag, or ATB_num_Match for a phone number.
+
−				For any other index_type, MATCH_NONE is returned as default.
+
−
+
− $Returns:		MATCH_EXACT, MATCH_START or MATCH_NONE
+
−
+
− $Arguments:	record1		The first record to be compared
+
−				record2		The second record to be compared
+
−				index_type	Indicator of the index_type which is to be matched
+
−
+
−*******************************************************************************/
+
−
+
−T_PB_MATCH ATB_index_Match(T_PB_RECORD *record1, T_PB_RECORD *record2, T_PB_INDEX index_type)
+
−{
+
−	T_PB_MATCH match;
+
−
+
−	match = GI_pb_Match(record1, record2, index_type);
+
−
+
−	if (match==MATCH_DEFAULT)
+
−	{
+
−		switch(index_type)
+
−		{
+
−			case INDEX_NAME:
+
−				match = ATB_alpha_Match(&record1->alpha, &record2->alpha);
+
−				break;
+
−			case INDEX_NUMBER:
+
−				match = ATB_num_Match(record1->number, record2->number);
+
−				break;
+
−		}
+
−	}
+
−
+
−	return match;
+
−}
+
−
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_index_Compare
+
− 
+
− $Description:	This function compares two records based on the index_type specified in
+
− 				index_type.  It returns a value indicating whether the first record should
+
− 				come before or after the second.
+
−				The function GI_pb_Compare is called first, to check whether there is
+
−				any user-specific sorting required.  If not, then ATB_alpha_Compare is
+
−				called for an alpha tag, or ATB_num_Compare for a phone number.
+
−				For any other index_type, COMPARE_FIRSTBEFORE is returned as default.
+
−
+
− $Returns:		COMPARE_IDENTICAL		The two records are identical
+
−				COMPARE_FIRSTBEFORE		The first record should come before the second record
+
−				COMPARE_FIRSTAFTER		The first record should come after the second record
+
−
+
− $Arguments:	record1		The first record to be compared
+
−				record2		The second record to be compared
+
−				index_type	Indicator of the index_type which is to be compared
+
−
+
−*******************************************************************************/
+
−
+
−T_PB_COMPARE ATB_index_Compare(T_PB_RECORD *record1, T_PB_RECORD *record2, T_PB_INDEX index_type)
+
−{
+
−	T_PB_COMPARE compare;
+
−	
+
−	compare = GI_pb_Compare(record1, record2, index_type);
+
−
+
−	if (compare==COMPARE_DEFAULT)
+
−	{
+
−		switch(index_type)
+
−		{
+
−			case INDEX_NAME:
+
−				compare = ATB_alpha_Compare(&record1->alpha, &record2->alpha);
+
−				break;
+
−			case INDEX_NUMBER:
+
−				compare = ATB_num_Compare(record1->number, record2->number);
+
−				break;
+
−		}
+
−	}
+
−
+
−	return compare;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_alpha_Compare
+
− 
+
− $Description:	This function compares two alpha strings on the basis of an ascending
+
− 				alphanumeric latin list, and specifies which record would come first.
+
−
+
−
+
− $Returns:		COMPARE_FIRSTBEFORE		The first record should come before the second record
+
−				COMPARE_FIRSTAFTER		The first record should come after the second record
+
−
+
− $Arguments:	alpha1				The first alpha tag
+
−				alpha2				The second alpha tag
+
−
+
−*******************************************************************************/
+
−
+
−T_PB_COMPARE ATB_alpha_Compare(T_PB_ALPHA *alpha1, T_PB_ALPHA *alpha2)
+
−{
+
−	T_PB_COMPARE compare;
+
−	SHORT charIndex;
+
−	USHORT length1 = alpha1->length;
+
−	USHORT length2 = alpha2->length;
+
−	USHORT char1;
+
−	USHORT char2;
+
−
+
−	compare = COMPARE_IDENTICAL;	/* Default */
+
−
+
−	/* Special case, length of first string is 0 */
+
−	
+
−	if (length1==0)
+
−		compare = COMPARE_FIRSTBEFORE;
+
−	
+
−	for (charIndex = 0; charIndex < length1; charIndex++)
+
−	{
+
−		if (charIndex==length2)	/* E.g. "Johnson" and "John" */
+
−		{
+
−			compare = COMPARE_FIRSTAFTER;
+
−			break;
+
−		}
+
−
+
−		char1 = alpha1->data[charIndex];
+
−		if (char1>=(SHORT)'A' && char1<=(SHORT)'Z')
+
−			char1 += (SHORT)('a'-'A');
+
−		char2 = alpha2->data[charIndex];
+
−		if (char2>=(SHORT)'A' && char2<=(SHORT)'Z')
+
−			char2 += (SHORT)('a'-'A');
+
−		
+
−		if (char1 < char2)
+
−		{
+
−			compare = COMPARE_FIRSTBEFORE;
+
−			break;
+
−		}
+
−		if (char1 > char2)
+
−		{
+
−			compare = COMPARE_FIRSTAFTER;
+
−			break;
+
−		}
+
−		if (charIndex==length1-1 && length2>length1)  /*E.g. "John" and "Johnson" */
+
−		{
+
−			compare = COMPARE_FIRSTBEFORE;
+
−			break;
+
−		}
+
−	}
+
−
+
−	return compare;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_alpha_Match
+
− 
+
− $Description:	This function matches two alpha strings on the basis of a latin string
+
− 				matched from the start, and specifies how they match.
+
−
+
− $Returns:		MATCH_NONE			The strings do not match
+
−				MATCH_START			The first string matches the start of the second string
+
−				MATCH_EXACT			The two strings match exactly
+
−
+
− $Arguments:	alpha1				The first alpha tag
+
−				alpha2				The second alpha tag
+
−
+
−*******************************************************************************/
+
−
+
−T_PB_MATCH ATB_alpha_Match(T_PB_ALPHA *alpha1, T_PB_ALPHA *alpha2)
+
−{
+
−	T_PB_MATCH match;
+
−	SHORT charIndex;
+
−	USHORT length1 = alpha1->length;
+
−	USHORT length2 = alpha2->length;
+
−	SHORT offset;
+
−	UBYTE searching;
+
−	UBYTE some_match;
+
−	USHORT char1, char2;
+
−
+
−	match = MATCH_EXACT;	/* Default */
+
−	searching = TRUE;
+
−	some_match = FALSE;
+
−	offset = 0;
+
−	
+
−	do
+
−	{
+
−		for (charIndex = 0; charIndex < length1; charIndex++)
+
−		{
+
−
+
−			if (charIndex==(length2-offset))	/* E.g. "Johnson" and "John" */
+
−			{
+
−				searching = FALSE;
+
−				break;							/* No match, will exit do/while */
+
−			}
+
−
+
−			char1 = alpha1->data[charIndex];
+
−			if (char1>=(SHORT)'A' && char1<=(SHORT)'Z')
+
−				char1 += (SHORT)('a'-'A');
+
−			char2 = alpha2->data[charIndex+offset];
+
−			if (char2>=(SHORT)'A' && char2<=(SHORT)'Z')
+
−				char2 += (SHORT)('a'-'A');
+
−		
+
−			if (char1 != char2)
+
−			{
+
−				some_match = FALSE;				/* Any fragment so far identified does not fit */
+
−				break;							/* No match, keep looking */
+
−			}
+
−
+
−			some_match = TRUE;
+
−
+
−			if (charIndex==length1-1 && length2>length1)  /*E.g. "John" and "Johnson" */
+
−			{
+
−				if (offset==0)
+
−					match = MATCH_START;
+
−				else
+
−					match = MATCH_FRAGMENT;
+
−				break;
+
−			}
+
−		}
+
−
+
−		if (some_match==TRUE)
+
−		{
+
−			searching = FALSE;
+
−		}
+
−		else
+
−		{
+
−			offset++;
+
−
+
−			/* If the fragment won't fit, don't keep looking */
+
−			if ((offset+length1)>length2)
+
−			{
+
−				match=MATCH_NONE;
+
−				searching = FALSE;
+
−			}
+
−		}
+
−	}while (searching);
+
−	
+
−	return match;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_num_Digit
+
− 
+
− $Description:	Extracts the four-bit digit from a BCD number
+
−
+
− $Returns:		The four bit digit
+
−
+
− $Arguments:	num				The BCD number
+
− 				numIndex		The position in the BCD number to look
+
−
+
−*******************************************************************************/
+
−
+
−UBYTE ATB_num_Digit(UBYTE *num, SHORT numIndex)
+
−{
+
−	UBYTE digit;
+
−	UBYTE shift = (numIndex&0x1)*0x4;
+
−		
+
−	digit = num[numIndex>>1];		/* Each BCD digit takes up half a byte */
+
−	digit &= (0xF<<shift);			/* Isolate the digit */
+
−	digit >>= shift;				/* Shift it so it has a value 0x0 - 0xF */
+
−	
+
−	return digit;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_num_Length
+
− 
+
− $Description:	Returns the length of a BCD number in digits
+
−
+
− $Returns:		Length of BCD number
+
−
+
− $Arguments:	num				The BCD number
+
−
+
−*******************************************************************************/
+
−
+
−SHORT ATB_num_Length(UBYTE *num)
+
−{
+
−	SHORT length;
+
−	
+
−	for (length = 0; ATB_num_Digit(num, length)!=0xF; length++)
+
−	{
+
−	}
+
−
+
−	return length;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_num_Compare
+
− 
+
− $Description:	This function compares two phone numbers by the standard comparison
+
− 				method (ascending numeric, from the end of the number) and specifies
+
− 				which record would come first if sorted in this method.
+
−
+
− $Returns:		COMPARE_FIRSTBEFORE		The first record should come before the second record
+
−				COMPARE_FIRSTAFTER		The first record should come after the second record
+
−
+
− $Arguments:	num1				The first number
+
−				num2				The second number
+
−
+
−*******************************************************************************/
+
−
+
−T_PB_COMPARE ATB_num_Compare(UBYTE *num1, UBYTE *num2)
+
−{
+
−	T_PB_COMPARE compare;
+
−	SHORT charIndex;
+
−	SHORT length1 = ATB_num_Length(num1);
+
−	SHORT length2 = ATB_num_Length(num2);
+
−	UBYTE digit1;
+
−	UBYTE digit2;
+
−
+
−	compare = COMPARE_IDENTICAL;	/* Default */
+
−	
+
−	for (charIndex = 0; charIndex < length1; charIndex++)
+
−	{
+
−		if (charIndex==length2)	/* E.g. "123456" and "1234" */
+
−		{
+
−			compare = COMPARE_FIRSTAFTER;
+
−			break;
+
−		}
+
−
+
−		digit1 = ATB_num_Digit(num1, (SHORT)(length1-charIndex-1));
+
−		digit2 = ATB_num_Digit(num2, (SHORT)(length2-charIndex-1));
+
−		
+
−		if (digit1 < digit2)
+
−		{
+
−			compare = COMPARE_FIRSTBEFORE;
+
−			break;
+
−		}
+
−		if (digit1 > digit2)
+
−		{
+
−			compare = COMPARE_FIRSTAFTER;
+
−			break;
+
−		}
+
−		if (charIndex==length1-1 && length2>length1)  /*E.g. "1234" and "123456" */
+
−		{
+
−			compare = COMPARE_FIRSTBEFORE;
+
−			break;
+
−		}
+
−	}
+
−
+
−	return compare;
+
−}
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_num_Match
+
− 
+
− $Description:	This function matches phone numbers, from the end backwards, and
+
− 				specifies how they match.
+
−
+
− $Returns:		MATCH_NONE			The numbers do not match
+
−				MATCH_START			The first number matches the end of the second number
+
−				MATCH_EXACT			The two numbers match exactly
+
−
+
− $Arguments:	num1				The first number
+
−				num2				The second number
+
−
+
−*******************************************************************************/
+
−
+
−T_PB_MATCH ATB_num_Match(UBYTE *num1, UBYTE *num2)
+
−{
+
−	T_PB_MATCH match;
+
−	SHORT charIndex;
+
−	SHORT length1 = ATB_num_Length(num1);
+
−	SHORT length2 = ATB_num_Length(num2);
+
−	SHORT offset;
+
−	UBYTE searching;
+
−	UBYTE some_match;
+
−	UBYTE digit1;
+
−	UBYTE digit2;
+
−
+
−	match = MATCH_EXACT;	/* Default */
+
−	searching = TRUE;
+
−	some_match = FALSE;
+
−	offset = 0;
+
−	
+
−	do
+
−	{
+
−		for (charIndex = 0; charIndex < length1; charIndex++)
+
−		{
+
−			if (charIndex==(length2-offset))	/* E.g. "12345" and "123" */
+
−			{
+
−				searching = FALSE;
+
−				break;							/* No match, will exit do/while */
+
−			}
+
−
+
−			digit1 = ATB_num_Digit(num1, (SHORT)(length1-charIndex-1));
+
−			digit2 = ATB_num_Digit(num2, (SHORT)(length2-charIndex-1));
+
−		
+
−			if (digit1 != digit2)
+
−			{
+
−				some_match = FALSE;				/* Any fragment so far identified does not fit */
+
−				break;							/* No match, keep looking */
+
−			}
+
−
+
−			some_match = TRUE;
+
−
+
−			if (charIndex==length1-1 && length2>length1)  /*E.g. "123" and "12345" */
+
−			{
+
−				if (offset==0)
+
−					match = MATCH_START;
+
−				else
+
−					match = MATCH_FRAGMENT;
+
−				break;
+
−			}
+
−		}
+
−
+
−		if (some_match==TRUE)
+
−		{
+
−			searching = FALSE;
+
−		}
+
−		else
+
−		{
+
−			offset++;
+
−
+
−			/* If the fragment won't fit, don't keep looking */
+
−			if ((offset+length1)>length2)
+
−			{
+
−				match=MATCH_NONE;
+
−				searching = FALSE;
+
−			}
+
−		}
+
−	} while (searching);
+
−	
+
−	return match;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_mem_UpdateCache
+
− 
+
− $Description:	Updates the cache with the record provided.  If the cache is full, the
+
− 				least used record is overwritten.
+
−
+
− $Returns:		None.
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier
+
−				index_type		The index table required.
+
−				phys_index		The physical index of the record to add.
+
−				record			The record to add.
+
−
+
−*******************************************************************************/
+
−
+
−void ATB_mem_UpdateCache(SHORT phonebook_id, SHORT phys_index, T_PB_RECORD *record)
+
−{
+
−	T_PB_DATA *data = ATB_hnd_GetPbData(phonebook_id);
+
−	SHORT cacheIndex;
+
−	SHORT leastUsed;
+
−	SHORT	leastIndex;
+
−	
+
−	/* First check if record is already in RAM */
+
−	
+
−	if (data->cache[phys_index] != NULL)
+
−	{
+
−		/* Copy the record in case it has changed */
+
−
+
−		ATB_pb_CopyRec(phonebook_id, data->cache[phys_index], record);
+
−		
+
−		if (data->in_memory[phys_index]<0x7FFF)/*a0393213 lint WR:Constant out of range Soln:0xffff changed to 0x7fff*/
+
−			data->in_memory[phys_index]++;
+
−		return;
+
−	}
+
−
+
−	/* If the cache is full, find the least accessed record */
+
−
+
−	if (data->cache_size==data->cache_max)
+
−	{
+
−		leastIndex = 0;
+
−		leastUsed = 255;
+
−			
+
−		for (cacheIndex=0; cacheIndex<data->records_max; cacheIndex++)
+
−		{
+
−			if (data->cache[cacheIndex]!=NULL && data->in_memory[cacheIndex] < leastUsed)
+
−			{
+
−				leastUsed = data->in_memory[cacheIndex];
+
−				leastIndex = cacheIndex;
+
−			}
+
−		}
+
−
+
−		/* Give the new record the memory allocated for the least used record */
+
−		
+
−		data->cache[phys_index] = data->cache[leastIndex];
+
−		data->cache[leastIndex] = NULL;
+
−		data->in_memory[leastIndex] = 0;
+
−	}
+
−	
+
−	/* If the cache is not full, allocate memory for record */
+
−	
+
−	else
+
−	{
+
−		data->cache[phys_index] = ATB_pb_AllocRec(phonebook_id);
+
−		data->cache_size++;
+
−	}
+
−
+
−	/* Copy the record into cache */
+
−
+
−	ATB_pb_CopyRec(phonebook_id, data->cache[phys_index], record);
+
−	data->in_memory[phys_index] = 1;
+
−
+
−	return;
+
−}
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_mem_ReadRec
+
− 
+
− $Description:	Reads a record from the logical position index.  Information is read from
+
− 				cache if it is present in memory, otherwise it will be read from file.
+
−
+
− 				The record information will be returned in the data structure pointed to
+
− 				by record.  The T_PB_RECORD structure must be allocated by the caller.
+
−
+
− $Returns:		PB_OK				Action completed OK.
+
−				PB_FILEREADFAIL		File read encountered an error
+
−				PB_RECDOESNOTEXIST	Tried to access a record that does not exist
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier
+
−				index_type		The index list from which the record is to be read
+
−				log_index		Logical index in the index list of the record to read
+
−				record			Structure in which to store record data
+
− 
+
−*******************************************************************************/
+
−
+
−PB_RET	ATB_mem_ReadRec(SHORT phonebook_id, T_PB_INDEX index_type, SHORT log_index, T_PB_RECORD *record)
+
−{
+
−	T_PB_DATA *data = ATB_hnd_GetPbData(phonebook_id);
+
−	SHORT phys_index;
+
−	PB_RET result;
+
−	
+
−	/* Check that record exists */
+
−
+
−	if (log_index<0
+
−		|| (log_index>=data->records_used && (index_type==INDEX_NAME || index_type==INDEX_NUMBER))
+
−		|| (index_type==INDEX_SEARCH && log_index>data->search_results)
+
−		|| (index_type==INDEX_PHYSICAL && log_index>data->records_max))
+
−	{
+
−		trace("*** Error - record does not exist ***");
+
−		return PB_RECDOESNOTEXIST;
+
−	}
+
−	
+
−	/* Get the corresponding physical record index */
+
−	
+
−	phys_index = ATB_index_GetPhysIndex(phonebook_id, index_type, log_index);
+
−
+
−	/* If the record is in the cache, simply copy it.  Otherwise, call FS to read the record. */
+
−	
+
−	if (data->in_memory[phys_index]>0)
+
−	{
+
−		ATB_pb_CopyRec(phonebook_id, record, data->cache[phys_index]);
+
−		result = PB_OK;
+
−	}
+
−	else
+
−	{
+
−		/* NB - assumes blocking read operation.  If the read operation is blocking,
+
−		 * the cache must be large enough to store all the phonebook entries. */
+
−		result = FS_pb_ReadRec(phonebook_id, phys_index, record);
+
−		ATB_mem_UpdateCache(phonebook_id, phys_index, record);
+
−	}
+
−
+
−	return result;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_hnd_GetPbData
+
− 
+
− $Description:	Returns phonebook data handle
+
−
+
− $Returns:		The phonebook data handle
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier
+
− 
+
−*******************************************************************************/
+
−
+
−T_PB_DATA*	ATB_hnd_GetPbData(SHORT phonebook_id)
+
−{
+
−	return phonebook[phonebook_id];
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	ATB_hnd_SetPbData
+
− 
+
− $Description:	Sets phonebook data handle
+
−
+
− $Returns:		None
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier
+
− 				data			The phonebook data
+
− 
+
−*******************************************************************************/
+
−
+
−void ATB_hnd_SetPbData(SHORT phonebook_id, T_PB_DATA *data)
+
−{
+
−	phonebook[phonebook_id] = data;
+
−
+
−	return;
+
−}
+
−