+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT: MMI-Framework (8417)         $Workfile:: ATBPbGI.c $|
+
−| 
+
−+--------------------------------------------------------------------+
+
−
+
−   MODULE  : ATBPbGI
+
−
+
−   PURPOSE : This modul contains phonebook management functions using ATB.
+
−
+
−   HISTORY:
+
−
+
−     Oct 27, 2005	REF: OMAPS 48881 b-nekkare
+
−      Description: PhoneBook: The modify option under phonebook doesn't 
+
−                        work as expected.
+
−      Solution :  Change is needed when we initially store the PB entry with 
+
−                      a '+' and then we delete the '+' and resave the number again. 
+
−	               If this is not done we would always end up preserving the TON 
+
−	               as INTERNATIONAL type
+
−*/
+
−#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 "mfw_phb.h"
+
−#include "mfw_cm.h"
+
−#include "mfw_ss.h"
+
−
+
−#include "cus_aci.h"
+
−#include "prim.h"
+
−#include "pcm.h"
+
−
+
−#include "ATBPb.h"
+
−#include "ATBPbGI.h"
+
−
+
−
+
−/*******************************************************************************
+
− * LOCAL FUNCTION PROTOTYPES
+
− *
+
− ******************************************************************************/
+
−
+
−void GI_alpha_AlphaToAscii(T_MFW_PHB_TEXT *ascii, T_PB_ALPHA *alpha, SHORT max_len);
+
−void GI_alpha_AsciiToAlpha(T_PB_ALPHA *alpha, T_MFW_PHB_TEXT *ascii, SHORT max_len);
+
−T_PB_INDEX GI_index_Convert(UBYTE mode);
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	GI_pb_GetPhonebook
+
− 
+
− $Description:	Checks to see which file system is selected
+
−
+
− $Returns:		MFW_PHB_OK			Action completed OK.
+
−				MFW_PHB_FAIL		File write encountered an error
+
−
+
− $Arguments:	intphonebook		Place to store type of phonebook selected
+
− 									(TRUE for FFS)
+
− 
+
−*******************************************************************************/
+
−
+
−T_MFW	GI_pb_GetPhonebook(UBYTE *intphonebook)
+
−{
+
−	PB_RET result;
+
−	T_MFW ret;
+
−	T_PB_TYPE current_type;
+
−
+
−	result = ATB_pb_GetPhonebook(PB_BOOK_DEFAULT, &current_type);
+
−
+
−	if (current_type==PB_TYPE_FFS)
+
−		*intphonebook = TRUE;
+
−	else
+
−		*intphonebook = FALSE;
+
−	
+
−	if (result==PB_OK)
+
−		ret = MFW_PHB_OK;
+
−	else
+
−		ret = MFW_PHB_FAIL;
+
−
+
−	return ret;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	GI_pb_SetPhonebook
+
− 
+
− $Description:	Selects file system
+
− 
+
− $Returns:		MFW_PHB_OK			Action completed OK.
+
−				MFW_PHB_FAIL		File write encountered an error
+
−
+
− $Arguments:	intphonebook		TRUE if FFS is to be used
+
− 
+
−*******************************************************************************/
+
−
+
−T_MFW	GI_pb_SetPhonebook(UBYTE intphonebook)
+
−{
+
−	PB_RET result;
+
−	T_MFW ret;
+
−	T_PB_TYPE current_type;
+
−
+
−	if (intphonebook)
+
−		current_type = PB_TYPE_FFS;
+
−	else
+
−		current_type = PB_TYPE_SIM;
+
−	
+
−	result = ATB_pb_SetPhonebook(PB_BOOK_DEFAULT, current_type);
+
−	
+
−	if (result==PB_OK)
+
−		ret = MFW_PHB_OK;
+
−	else
+
−		ret = MFW_PHB_FAIL;
+
−
+
−	return ret;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	GI_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.
+
− 				
+
− $Returns:		MFW_PHB_OK
+
− 				MFW_PHB_FAIL
+
−
+
− $Arguments:	None
+
−								
+
−*******************************************************************************/
+
−
+
−T_MFW	GI_pb_Initialise(void)
+
−{
+
−	PB_RET result;
+
−	T_MFW ret;
+
−
+
−	tracefunction("GI_pb_Initialise");
+
−
+
−	result = ATB_pb_Initialise(PB_BOOK_DEFAULT, PB_TYPE_FFS, PB_RECORDS_MAX,
+
−		PB_CACHE_MAX, PB_ALPHATAG_MAX, PB_NUMBER_MAX, PB_EXT_MAX);
+
−
+
−	switch(result)
+
−	{
+
−		case PB_OK:
+
−			ret = MFW_PHB_OK;
+
−			break;
+
−		case PB_EXCT:
+
−			ret = MFW_PHB_OK;
+
−			break;
+
−		case PB_BOOKALREADYEXISTS:
+
−			ret = MFW_PHB_FAIL;
+
−			break;
+
−	}
+
−
+
−	return ret;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	GI_pb_Exit
+
− 
+
− $Description:	Frees memory associated with phonebook.  To be called when the
+
− 				phonebook is no longer required, or at shutdown.
+
−
+
− $Returns:		MFW_PB_OK		Action completed OK.
+
−
+
− $Arguments:	None
+
− 
+
−*******************************************************************************/
+
−
+
−T_MFW	GI_pb_Exit(void)
+
−{
+
−	tracefunction("GI_pb_Exit");
+
−
+
−	ATB_pb_Exit(PB_BOOK_DEFAULT);
+
−	return MFW_PHB_OK;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	GI_pb_Info
+
− 
+
− $Description:	Returns information about the phonebook, which will be returned
+
− 				in the data structure pointed to by status.  The caller must
+
− 				allocate the T_MFW_PHB_STATUS structure.
+
−
+
− $Returns:		MFW_PB_OK		Action completed OK.
+
−
+
− $Arguments:	status			Data structure to contain phonebook info
+
− 
+
−*******************************************************************************/
+
−
+
−void GI_pb_Info(T_MFW_PHB_STATUS *status)
+
−{
+
−	T_PB_INFO info;
+
−
+
−	tracefunction("GI_pb_Info");
+
−
+
−	ATB_pb_Info(PB_BOOK_DEFAULT, &info);
+
−	
+
−	status->book = PHB_IPB;
+
−	status->max_entries = (UBYTE)info.records_max;
+
−	status->used_entries = (UBYTE)info.records_used;
+
−	status->avail_entries = (UBYTE)info.records_free;
+
−	status->tag_len = PHB_MAX_LEN;
+
−
+
−	return;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	GI_pb_Status
+
− 
+
− $Description:	Returns whether or not the phonebook is busy.  If so, stat will contain
+
− 				PHB_BUSY, otherwise PHB_READY.
+
−
+
− $Returns:		None
+
−
+
− $Arguments:	stat			UBYTE to contain status information
+
− 
+
−*******************************************************************************/
+
−
+
−void GI_pb_Status(UBYTE *stat)
+
−{
+
−	PB_RET result;
+
−	
+
−	tracefunction("GI_pb_Status");
+
−
+
−	result = ATB_pb_Status(PB_BOOK_DEFAULT);
+
−	
+
−	return;
+
−}
+
−
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	GI_pb_WriteRec
+
− 
+
− $Description:	Writes a record to the physical position index.  If the index is
+
− 				0, a new record is added, otherwise the previous
+
− 				record at that position is overwritten.
+
−
+
− $Returns:		MFW_PHB_OK
+
− 				MFW_PHB_FAIL
+
− 				MFW_PHB_FULL
+
−
+
− $Arguments:	entry	The phonebook entry to write
+
− 
+
−*******************************************************************************/
+
−
+
−T_MFW	GI_pb_WriteRec(T_MFW_PHB_ENTRY *entry)
+
−{
+
−	T_MFW ret;
+
−	PB_RET result;
+
−	SHORT	index;
+
−	T_PB_RECORD *record;
+
−	UBYTE *number;
+
−
+
−	tracefunction("GI_pb_WriteRec");
+
−
+
−	/* Allocate memory for record */
+
−
+
−	record = ATB_pb_AllocRec(PB_BOOK_DEFAULT);
+
−	
+
−	/* If the provided index is 0, we must add new record */
+
−	
+
−	if (entry->index==0)
+
−		index = PB_NEW_RECORD;
+
−	else
+
−		index = (SHORT)(entry->index-1);	/* MFW/ACI indices start at 1, ATB indices start at 0 */
+
−
+
−	/* Convert name to unicode*/
+
−	
+
−	record->alpha.dcs = entry->name.dcs;
+
−	record->alpha.length = (UBYTE)entry->name.len;
+
−	GI_alpha_AsciiToAlpha(&record->alpha, &entry->name, PHB_MAX_LEN);
+
−
+
−	/* Convert number to BCD */
+
−
+
−	record->ton_npi = entry->npi & 0x0F;
+
−	record->ton_npi |= (entry->ton<<4);
+
−	
+
−	number = entry->number;
+
−
+
−	if (number[0]=='+')
+
−	{
+
−		record->ton_npi &= 0xF0;
+
−		record->ton_npi |= (MFW_TON_INTERNATIONAL<<4);
+
−		number++;
+
−	}
+
−	// Oct 27, 2005	REF: OMAPS OMAPS00048881 b-nekkare
+
−	else if(entry->ton == MFW_TON_INTERNATIONAL)
+
−	{
+
−              record->ton_npi = entry->npi & 0x0F;
+
−              record->ton_npi |= (MFW_TON_UNKNOWN<<4);
+
−	}
+
−       /* Anything else keep as is */
+
−
+
−	TRACE_EVENT_P1("ton_npi: %X", record->ton_npi);
+
−  
+
−	ATB_pb_CharToBCD(record->number, (char *)number, PB_NUMBER_MAX);
+
−
+
−	/* Write the record */
+
−	
+
−	result = ATB_pb_WriteRec(PB_BOOK_DEFAULT, INDEX_PHYSICAL, index, record);
+
−
+
−	/* Free allocated record */
+
−
+
−	ATB_pb_FreeRec(PB_BOOK_DEFAULT, record);
+
−	
+
−	switch(result)
+
−	{
+
−		case PB_OK:
+
−			ret = MFW_PHB_OK;
+
−			break;
+
−		case PB_BOOKFULL:
+
−			ret = MFW_PHB_FULL;
+
−			break;
+
−		default:
+
−			ret = MFW_PHB_FAIL;
+
−			break;
+
−	}
+
−
+
−	return ret;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	GI_pb_DeleteRec
+
− 
+
− $Description:	Deletes a record at a physical position index.
+
−
+
− $Returns:		MFW_PHB_OK
+
− 				MFW_PHB_FAIL
+
− 
+
− $Arguments:	index		Physical index of the record to delete
+
−
+
−*******************************************************************************/
+
−
+
−T_MFW	GI_pb_DeleteRec(UBYTE index)
+
−{
+
−	T_MFW ret;
+
−	PB_RET result;
+
−
+
−	tracefunction("GI_pb_DeleteRec");
+
−
+
−	/* MFW/ACI indices start at 1, ATB indices start at 0 */
+
−
+
−	index--;
+
−
+
−	/* Delete record */
+
−	
+
−	result = ATB_pb_DeleteRec(PB_BOOK_DEFAULT, INDEX_PHYSICAL, (SHORT)index);
+
−
+
−	switch(result)
+
−	{
+
−		case PB_OK:
+
−			ret = MFW_PHB_OK;
+
−			break;
+
−		default:
+
−			ret = MFW_PHB_FAIL;
+
−			break;
+
−	}
+
−
+
−	return ret;	
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	GI_pb_Find
+
− 
+
− $Description:	Find the nearest match to the supplied record. 
+
−
+
− $Returns:		MFW_PHB_OK
+
− 				MFW_PHB_FAIL
+
−
+
− $Arguments:	mode 			Specifies the sorting for the index list
+
−				index			Place to store the index of the matching record
+
−				num_recs		Number of records to read in
+
−				search_pattern	The string or number to match
+
−				entries			Place to store the resulting list of entries
+
− 
+
−*******************************************************************************/
+
−
+
−T_MFW GI_pb_Find(UBYTE mode, UBYTE *index, UBYTE num_recs,  T_MFW_PHB_TEXT *search_pattern, T_MFW_PHB_LIST *entries)
+
−{
+
−	PB_RET result;
+
−	T_MFW ret;
+
−	T_PB_INDEX index_type = GI_index_Convert(mode);
+
−	T_PB_RECORD *record;
+
−	SHORT recs_count;
+
−	SHORT rec_index;
+
−	UBYTE *number;
+
−
+
−	tracefunction("GI_pb_Find");
+
−
+
−	/* Allocate memory for record */
+
−
+
−	record = ATB_pb_AllocRec(PB_BOOK_DEFAULT);
+
−
+
−	/* Convert name to unicode, or number to BCD */
+
−		
+
−	if(index_type==INDEX_NAME)
+
−	{
+
−		GI_alpha_AsciiToAlpha(&record->alpha, search_pattern, PB_ALPHATAG_MAX);
+
−	}
+
−    else
+
−    {
+
−    	/* Convert number to BCD */
+
−
+
−		number = search_pattern->data;
+
−		
+
−		if (number[0]=='+')
+
−		{
+
−			number++;
+
−		}
+
−      	ATB_pb_CharToBCD(record->number, (char *)number, PB_NUMBER_MAX);
+
−	}
+
−
+
−	result = ATB_pb_Find(PB_BOOK_DEFAULT, index_type, record, &rec_index, NULL);
+
−	
+
−	if (result==PB_OK)
+
−	{
+
−		*index = rec_index+1;	/* MFW/ACI indices start at 1, ATB indices start at 0 */
+
−		result = GI_pb_ReadRecList(mode, (UBYTE)(*index), num_recs, entries);
+
−	}
+
−
+
−	/* Free allocated record */
+
−
+
−	ATB_pb_FreeRec(PB_BOOK_DEFAULT, record);
+
−
+
−	
+
−	switch(result)
+
−	{
+
−		case PB_OK:
+
−			ret = MFW_PHB_OK;
+
−			break;
+
−		default:
+
−			ret = MFW_PHB_FAIL;
+
−			break;
+
−	}
+
−	
+
−	return ret;
+
−}
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	GI_pb_ReadRecList
+
− 
+
− $Description:	Read in a list of entries.
+
−
+
− $Returns:		MFW_PHB_OK
+
− 				MFW_PHB_FAIL
+
−
+
− $Arguments:	mode 			Specifies the sorting for the index list
+
−				index			Place to store the index of the matching record
+
−				num_recs		Number of records to read in
+
−				entries			Place to store the resulting list of entries
+
− 
+
−*******************************************************************************/
+
−
+
−T_MFW GI_pb_ReadRecList(UBYTE mode, UBYTE index, UBYTE num_recs, T_MFW_PHB_LIST *entries)
+
−{
+
−	PB_RET result;
+
−	T_MFW ret;
+
−	T_PB_INDEX index_type = GI_index_Convert(mode);
+
−	T_PB_RECORD *record;
+
−	SHORT recs_count;
+
−
+
−	tracefunction("GI_pb_ReadRecList");
+
−
+
−	/* MFW/ACI indices start at 1, ATB indices start at 0 */
+
−	
+
−	index--;
+
−
+
−	/* Allocate memory for record */
+
−
+
−	record = ATB_pb_AllocRec(PB_BOOK_DEFAULT);
+
−
+
−	for (recs_count = 0; recs_count<(SHORT)num_recs; recs_count++)
+
−	{
+
−		result = ATB_pb_ReadRec(PB_BOOK_DEFAULT, index_type, (SHORT)(index+recs_count), record);
+
−		if (result!=PB_OK)
+
−			break;
+
−		
+
−		entries->entry[recs_count].book = PHB_IPB;
+
−		entries->entry[recs_count].index = GI_pb_ConvIndex(index_type, (UBYTE)(index+recs_count), INDEX_PHYSICAL);
+
−		entries->entry[recs_count].ton = (record->ton_npi & 0xF0)>>4;
+
−		entries->entry[recs_count].npi = record->ton_npi & 0x0F;
+
−		GI_alpha_AlphaToAscii(&entries->entry[recs_count].name, &record->alpha, PB_ALPHATAG_MAX);
+
−		ATB_pb_BCDToChar((char *)entries->entry[recs_count].number, record->number, PB_NUMBER_MAX);
+
−	}
+
−
+
−	entries->book = PHB_IPB;
+
−
+
−	if (recs_count)
+
−	{
+
−	    entries->result = MFW_ENTRY_EXIST;
+
−	    entries->num_entries = (UBYTE) recs_count;
+
−	    /* SPR#1994 - SH - If at least one record is found, result is a success */
+
−		result = PB_OK;
+
−	}
+
−	else
+
−	{
+
−		entries->result = MFW_NO_ENTRY;
+
−	}
+
−
+
−	/* Free allocated record */
+
−
+
−	ATB_pb_FreeRec(PB_BOOK_DEFAULT, record);
+
−		
+
−	switch(result)
+
−	{
+
−		case PB_OK:
+
−			ret = MFW_PHB_OK;
+
−			break;
+
−		case PB_RECDOESNOTEXIST:
+
−			ret = MFW_PHB_FAIL;
+
−			break;
+
−		default:
+
−			ret = MFW_PHB_FAIL;
+
−			break;
+
−	}
+
−
+
−	return ret;
+
−}
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	GI_pb_ConvIndex
+
− 
+
− $Description:	Returns the index in table new_index_type corresponding to the index
+
− 				in table index_type.
+
− 
+
− $Returns:		The new index
+
−
+
− $Arguments:	index_type		The index table of the original index.
+
−				index			The original logical index.
+
−				new_index_type	The index table required.
+
−				
+
−*******************************************************************************/
+
−
+
−UBYTE GI_pb_ConvIndex(T_PB_INDEX index_type, UBYTE index, T_PB_INDEX new_index_type)
+
−{
+
−	SHORT new_index;
+
−
+
−	tracefunction("GI_pb_ConvIndex");
+
−	
+
−	ATB_pb_ConvIndex(PB_BOOK_DEFAULT, index_type, (SHORT)index, new_index_type, &new_index);
+
−
+
−	/* MFW/ACI indices start at 1, ATB indices start at 0 */
+
−
+
−	if (new_index_type==INDEX_PHYSICAL)
+
−	{
+
−		new_index++;
+
−	}
+
−	
+
−	return (UBYTE)new_index;
+
−}
+
−
+
−
+
−/********************************
+
− * Functions called by the ATB PB  *
+
− ********************************/
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	GI_pb_OK
+
− 
+
− $Description:	This function is called if the requested command executed successfully.
+
− 				The param parameter is a pointer to command specific information,
+
− 				when such information is required to be passed from the ATB to the GI.
+
− 				See the individual functions for more details.
+
− 
+
− $Returns:		None.
+
−
+
− $Arguments:	phonebook_id	The phonebook identifier
+
−				command_id		Identifies the command.
+
−				param			Pointer to command-specific information
+
− 
+
−*******************************************************************************/
+
−
+
−void GI_pb_OK(SHORT phonebook_id, SHORT command_id, void *param)
+
−{
+
−	trace("GI_pb_OK");
+
−
+
−	if (param!=NULL)
+
−	{
+
−		trace_P1("Param is: %d", *((SHORT *)param));
+
−	}
+
−}
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	GI_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
+
−				command_id		Identifies the command.
+
−				error_id		Identifies the error that occurred.
+
− 
+
−*******************************************************************************/
+
−
+
−void GI_pb_Error(SHORT phonebook_id, SHORT command_id, SHORT error_id)
+
−{
+
−	trace("GI_pb_Error");
+
−	trace_P2("***ERROR*** - command %d, error %d", command_id, error_id);
+
−
+
−	return;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	GI_pb_MemAlloc
+
− 
+
− $Description:	Dynamically allocates memory for the phonebook.
+
− 
+
− $Returns:		The address of the block of allocated memory, or NULL if failed.
+
−
+
− $Arguments:	size	- Amount of memory to be allocated in bytes
+
− 
+
−*******************************************************************************/
+
−// Dec 22, 2004 REF: CRR MFW-SPR-27847 xnkulkar
+
−// Description: MFW memory size variable changed from U16 -> U32
+
−// Solution: The use of variable U16 has been replaced with U32
+
−
+
−UBYTE *GI_pb_MemAlloc(U32 size)
+
−{
+
−	return mfwAlloc((U32)size);
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	GI_pb_MemFree
+
− 
+
− $Description:	Frees dynamically allocated memory.
+
− 
+
− $Returns:		None
+
− 
+
− $Arguments:	mem - Pointer to a block of allocated memory
+
− 				size - Size of the block
+
− 
+
−*******************************************************************************/
+
−// Dec 22, 2004 REF: CRR MFW-SPR-27847 xnkulkar
+
−// Description: MFW memory size variable changed from U16 -> U32
+
−// Solution: The use of variable U16 has been replaced with U32
+
−
+
−void GI_pb_MemFree(UBYTE *mem, U32 size)
+
−{
+
−	mfwFree(mem, (U32)size);
+
−	return;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	GI_pb_Match
+
− 
+
− $Description:	This function allows the user to specify the way in which entries are
+
− 				matched during searching.  This provides the capability of searching
+
− 				languages with non-Latin alphabets, or searching through special user
+
− 				fields.
+
−				This function attempts a match between two records based on the
+
−				field appropriate for the index list, 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).
+
−				Note that the contents of the records themselves should not be altered
+
−				by this function.  The sole result should be a return value that specifies
+
−				how the first record matches the second.  If it is preferred that the
+
−				default matching routine is used (i.e match from the start for alpha
+
−				tags, match from the end for phone numbers) then MATCH_DEFAULT
+
−				should be returned.
+
−
+
− $Returns:		MATCH_DEFAULT, 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 field which is to be compared
+
− 
+
−*******************************************************************************/
+
−
+
−T_PB_MATCH GI_pb_Match(T_PB_RECORD *record1,T_PB_RECORD *record2, T_PB_INDEX index_type)
+
−{
+
−	return MATCH_DEFAULT;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	GI_pb_Compare
+
− 
+
− $Description:	This function allows the user to specify the way in which entries are
+
− 				compared during sorting.  This provides the capability of sorting languages
+
− 				with non-Latin alphabets, or sorting to alternative orders (for example,
+
− 				reverse alphabetical).
+
−				This function compares two records based on the field appropriate for the
+
−				index list, specified in index_type.
+
−				It returns a value indicating whether the first record should come before
+
−				or after the second.
+
−				Note that the contents of the records themselves should not be altered by
+
−				this function.  The sole result should be a return value that specifies
+
−				whether or not the positions of the records should be swapped.  If it
+
−				is preferred that the default comparison routine is used (e.g.Latin
+
−				alphabetical ascending) then COMPARE_DEFAULT should be returned.
+
−
+
−
+
− $Returns:		COMPARE_DEFAULT		No comparison made - use the default comparison method
+
−				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	Index list to use
+
− 
+
−*******************************************************************************/
+
−
+
−T_PB_COMPARE GI_pb_Compare (T_PB_RECORD *record1,T_PB_RECORD *record2, T_PB_INDEX index_type)
+
−{
+
−	return COMPARE_DEFAULT;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	GI_pb_GetTable
+
− 
+
− $Description:	If fields other than name and number are required, then index tables
+
− 				must be provided for each field.  This function is called when access
+
− 				to an index table is required for an unknown index type.
+
−
+
− 				The array provided must be a user-allocated array of type SHORT,
+
− 				records_max in size, e.g.
+
−
+
− 				static SHORT user_table[RECORDS_MAX];
+
− 				return user_table;
+
−
+
− $Returns:		A pointer to an array of SHORTs records_max in size.
+
−
+
− $Arguments:	index_type	Index list to use
+
− 
+
−*******************************************************************************/
+
−
+
−SHORT *GI_pb_GetTable (T_PB_INDEX index_type)
+
−{
+
−	SHORT *user_table = NULL;	/*DUMMY IMPLEMENTATION*/
+
−	return user_table;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	GI_alpha_AlphaToAscii
+
− 
+
− $Description:	Convert an alpha tag to an ascii string
+
−
+
− $Returns:		None
+
−
+
− $Arguments:	ascii		The ascii string
+
− 				alpha		The alpha tag
+
− 				max_len		The maximum length of the resulting string
+
− 
+
−*******************************************************************************/
+
−
+
−void GI_alpha_AlphaToAscii(T_MFW_PHB_TEXT *ascii, T_PB_ALPHA *alpha, SHORT max_len)
+
−{
+
−	SHORT asciiIndex;
+
−	SHORT alphaIndex;
+
−
+
−	/* Unicode entry - swap the low and high bytes, add in 0x80 at start*/
+
−
+
−	ascii->dcs = alpha->dcs;
+
−	
+
−	if (alpha->dcs == MFW_DCS_UCS2)
+
−	{
+
−		ascii->data[0] = 0x80;
+
−		asciiIndex = 1;
+
−		alphaIndex = 0;
+
−		
+
−		while (alphaIndex<alpha->length && asciiIndex<max_len)
+
−		{
+
−			ascii->data[asciiIndex++] = (char) (alpha->data[alphaIndex]>>8);
+
−			ascii->data[asciiIndex++] = (char) (alpha->data[alphaIndex] & 0xFF);
+
−			alphaIndex++;
+
−		}
+
−
+
−		/* Put two NULLs at the end, if there is space */
+
−		
+
−		if (asciiIndex<max_len)
+
−			ascii->data[asciiIndex++] = NULL;
+
−		if (asciiIndex<max_len)
+
−			ascii->data[asciiIndex] = NULL;
+
−
+
−		ascii->len = asciiIndex;
+
−	}
+
−
+
−	/* Ascii entry - convert from unicode */
+
−	
+
−	else
+
−	{
+
−		asciiIndex = 0;
+
−		alphaIndex = 0;
+
−		
+
−		while (alphaIndex<alpha->length && asciiIndex<max_len)
+
−		{
+
−			ascii->data[asciiIndex++] = (char) (alpha->data[alphaIndex++]);
+
−		}
+
−
+
−		/* Put a NULL at the end, if there is space */
+
−
+
−		if (asciiIndex<max_len)
+
−			ascii->data[asciiIndex] = NULL;
+
−
+
−		ascii->len = asciiIndex;
+
−	}
+
−	
+
−	return;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	GI_alpha_AsciiToAlpha
+
− 
+
− $Description:	Convert an ascii string to an alpha tag
+
−
+
− $Returns:		None
+
−
+
− $Arguments:	alpha		The alpha tag
+
− 				ascii		The ascii string
+
− 				max_len		The maximum length of the resulting string
+
− 
+
−*******************************************************************************/
+
−
+
−void GI_alpha_AsciiToAlpha(T_PB_ALPHA *alpha, T_MFW_PHB_TEXT *ascii, SHORT max_len)
+
−{
+
−	SHORT asciiIndex;
+
−	SHORT alphaIndex;
+
−
+
−	alpha->dcs = ascii->dcs;
+
−	
+
−	/* Unicode entry - swap the low and high bytes, ignore first '0x80' character */
+
−	
+
−	if (ascii->dcs == MFW_DCS_UCS2)
+
−	{
+
−		asciiIndex = 1;
+
−		alphaIndex = 0;
+
−	
+
−		while (asciiIndex<ascii->len && alphaIndex<max_len)
+
−		{
+
−			alpha->data[alphaIndex++] = (USHORT) ((ascii->data[asciiIndex++]<<8) | ascii->data[asciiIndex++]);
+
−		}
+
−
+
−		/* Put a NULL at the end, if there is space */
+
−		
+
−		if (alphaIndex<max_len)
+
−			alpha->data[alphaIndex] = NULL;
+
−	}
+
−
+
−	/* Ascii entry - convert to unicode */
+
−	
+
−	else
+
−	{
+
−		asciiIndex = 0;
+
−		alphaIndex = 0;
+
−	
+
−		while (asciiIndex<ascii->len && alphaIndex<max_len)
+
−		{
+
−			alpha->data[alphaIndex++] = (USHORT)ascii->data[asciiIndex++];
+
−		}
+
−		
+
−		/* Put a NULL at the end, if there is space */
+
−		
+
−		if (alphaIndex<max_len)
+
−			alpha->data[alphaIndex] = NULL;
+
−	}
+
−	
+
−	alpha->length = alphaIndex;
+
−
+
−	return;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−
+
− $Function:    	GI_index_Convert
+
− 
+
− $Description:	Convert indexing types from MFW to ATB.
+
−
+
− $Returns:		The ATB indexing type
+
−
+
− $Arguments:	mode		The MFW sort mode
+
− 
+
−*******************************************************************************/
+
−
+
−T_PB_INDEX GI_index_Convert(UBYTE mode)
+
−{
+
−	T_PB_INDEX index_type;
+
−	
+
−	switch(mode)
+
−	{
+
−		case MFW_PHB_ALPHA:
+
−			index_type = INDEX_NAME;
+
−			break;
+
−		case MFW_PHB_NUMBER:
+
−			index_type = INDEX_NUMBER;
+
−			break;
+
−		case MFW_PHB_INDEX:
+
−			index_type = INDEX_PHYSICAL;	/* NOTE - may not work quite as intended */
+
−			break;
+
−		case MFW_PHB_PHYSICAL:
+
−			index_type = INDEX_PHYSICAL;
+
−			break;
+
−	}
+
−
+
−	return index_type;
+
−}