FreeCalypso > hg > fc-magnetite
view src/ui3/atb/ATBCommon.c @ 450:395e464e4005
Compal & Pirelli targets: APCOFF register setting
changed to match what the respective original firmwares set
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Mon, 05 Mar 2018 04:01:30 +0000 |
| parents | e8ddbb0837ed |
| children |
line wrap: on
line source
/******************************************************************************* 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: ATBCommon.c $Revision: $Author: SH - Condat(UK) $Date: ******************************************************************************** Description: ATB Common functions and definitions. ******************************************************************************** $History: ATBCommon.c May 7, 2007 OMAPS00130278 a0393213(R.Prabakar) Description : CT-GCF[34.2.5.1] - MS fails to display class 0 MT SMS when it contains alphanumeric and special characters Nov 24, 2006 DR: OMAPS00092906 - x0039928 Description: CT-GCF[34.3]-Some broadcasted charcters not dispayed correctly in MMI Solution: g_translation_8bit_table[] array is modified. Changed code 0xFF to 0x1B. Jun 09, 2006 DR: OMAPS00080543 - xreddymn ATB_convert_String does not work correctly for 7-bit GSM to 8-bit conversion. This is due to a dependency with ACI function. This has been replaced now with an independent conversion function, which ATB_convert_String can call. Mar 30, 2005 REF: CRR 29986 xpradipg Description: Optimisation 1: Removal of unused variables and dynamically allocate/ deallocate mbndata Solution: removed the definition of translation_ascii_2_unicode and added the extern declaration March 24, 2005 REF: CRR MMI-FIX-9828 x0012852 Description: BMI having problems with Umlauts ,especially "? Solution: g_translation_8bit_table[] array is modified . Changed codes 0x80 , 0x81, 0x82 to ox81, 0x82 ,0x83 respectively. Jan 05, 2005 REF: CRR MMI-FIX-24757 xnkulkar Description: the display doesn´t show special chars correctly; if there is an "@" in the text, the "@" and text after is not visible Solution: Fix for MMI-SPR-25978 has solved the problem of data loss after '@' symbol. However, some other symbols (like ?etc.) were not displayed properly. Modified the g_translation_8bit_table[] array to take care of all the special GSM character set . Nov 30, 2004 REF: CRR MMI-SPR-25978 xnkulkar Description: Messages:Not able to receive message after @ in the receiver phone (Bug raised in 3.x) Solution: in g_translation_8bit_table, the value for '@' symbol was used as 0x00. It has been changed to 0x40 now. 26-05-04 CRR 19656 Sandip and Deepa M.D Fix for The Dsample doesn't display lines ( <CR> or <LF> ) in the SETUP IDLE TEXT command. Fix for The idle screen is empty when a SETUP IDLE TEXT command is sent with a long text ( 239 characters ). $End *******************************************************************************/ /* includes */ #include <string.h> #include <stdio.h> #include <stdlib.h> #if defined (NEW_FRAME) #include "typedefs.h" #include "vsi.h" #include "pei.h" #include "custom.h" #include "gsm.h" #else #include "STDDEFS.H" #include "custom.h" #include "gsm.h" #include "vsi.h" #endif #include "mfw_mfw.h" #include "mfw_win.h" #include "mfw_kbd.h" #include "mfw_tim.h" #include "mfw_phb.h" #include "mfw_sms.h" #include "mfw_ss.h" #include "mfw_icn.h" #include "mfw_mnu.h" #include "mfw_lng.h" #include "mfw_sat.h" #include "mfw_kbd.h" #include "mfw_nm.h" #include "mfw_cm.h" #include "ATBCommon.h" /*SPR2175, Added macro and tables for string conversion routines*/ #define MAX_STRING_LEN (5+MFW_NUM_LEN+MAX_MSG_LEN+4) /*SPR 1508, changed codes 128, 129 and 130 to 129, 130, and 131 respectively.*/ static const unsigned char g_translation_ascii_table[128] = { 64, 156, 36, 157, 138, 131, 151, 141, 149, 129, 10, 2 , 7, 32, 143, 134, 4, 95, 232, 226, 239, 234, 227, 5, 228, 233, 240, 27, 146, 145, 225, 144, 32, 33, 34, 35, 1, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 173, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 142, 153, 165, 154, 168, 06, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 132, 148, 164, 130, 133}; static const int g_translation_unicode[128] = { 0x0040, 0x00A3, 0x0024, 0x00A5, 0x00E8, 0x00E9, 0x00F9, 0x00EC, 0x00F2, 0x00C7, 0x000A, 0x00D8, 0x00F8, 0x000D, 0x00C5, 0x00E5, 0x0394, 0x005F, 0x03A6, 0x0393, 0x039B, 0x03A9, 0x03A0, 0x03A8, 0x03A3, 0x0398, 0x039E, 0x03A2, 0x00C6, 0x00E6, 0x00DF, 0x00C9, 0x0020, 0x0021, 0x0022, 0x0023, 0x00A4, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F, 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F, 0x00A1, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005A, 0x00C4, 0x00D6, 0x00D1, 0x00DC, 0x00A7, 0x00BF, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F, 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007A, 0x00E4, 0x00F6, 0x00F1, 0x00FC, 0x00E0}; /*SPR 1508, added conversion table*/ // Mar 30, 2005 REF: CRR 29986 xpradipg // remove the definition of the table #ifdef FF_MMI_OPTIM extern const int translation_ascii_2_unicode[]; #else static const int translation_ascii_2_unicode[256] = { 0x0000, 0x00A4, 0x00d8, 0xFFFF, 0x0394, 0x03A8, 0x00BF, 0x00F8, 0xFFFF, 0xFFFF, 0x000A, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026,0x0027, 0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F, 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F, 0x0040,0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005A, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x005F, 0xFFFF, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F, 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007A, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x00C7, 0x00FC, 0x00E9, 0x00E4, 0x00E0, 0x00E5, 0xFFFF, 0xFFFF, 0xFFFF, 0x00E8, 0xFFFF, 0xFFFF, 0x00EC, 0x00C4, 0x00C5, 0x00C9, 0x00E6, 0x00C6, 0xFFFF, 0x00F6, 0x00F2, 0xFFFF, 0x00F9, 0xFFFF, 0x00D6, 0x00DC, 0xFFFF, 0x00A3, 0x00A5, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x00F1, 0x00D1, 0xFFFF, 0xFFFF, 0x00A7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x00A1, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x00DF, 0x0393, 0x03A0, 0x03A3, 0xFFFF, 0xFFFF, 0xFFFF, 0x03A6, 0x0398, 0x03A9, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x039B, 0x039E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF }; #endif // MMI_FIX-19656 Using 8 bit table for dispay start // Nov 30, 2004 REF: CRR MMI-SPR-25978 xnkulkar // Description: Messages:Not able to receive message after @ in the receiver phone (Bug raised in 3.x) // Solution: in g_translation_8bit_table, the value for '@' symbol was used as 0x00. It has been // changed to 0x40 now. // Jan 05, 2005 REF: CRR MMI-FIX-24757 xnkulkar // Description: the display doesn´t show special chars correctly; if there is an "@" in the text, the "@" and // text after is not visible // Solution: Fix for MMI-SPR-25978 has solved the problem of data loss after '@' symbol. However, some other // symbols (like ?etc.) were not displayed properly. Modified the g_translation_8bit_table[] array // to take care of all the special GSM character set . // March 24, 2005 REF: CRR MMI-FIX-9828 x0012852 // Description: BMI having problems with Umlauts ,especially "? // Solution: g_translation_8bit_table[] array is modified . Changed codes 0x80 , 0x81, // 0x82 to ox81, 0x82 ,0x83 respectively. static const unsigned char g_translation_8bit_table[256] ={ 0x40, 0x9C, 0x24, 0x9D, 0x8A, 0x83, 0x97, 0x8D, 0x95, 0x81, 0x0A, 0x02, 0x07, 0x20, 0x8F, 0x86, 0x04, 0x5F, 0xE8, 0xE2, 0xEF, 0xEA, 0xE3, 0x05, 0xE4, 0xE9,0xF0, 0x1B, 0x92, 0x91, 0xE1, 0x90, 0x20, 0x21, 0x22, 0x23, 0x01, 0x25, 0x26,0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0xAD,0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x8E, 0x99, 0xA5, 0x9A, 0xA8, 0x06, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x84, 0x94, 0xA4, 0x82, 0x85, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; //MMI_FIX-19656 Using 8 bit table for dispay start static char convertUCS2_2_ascii_char(char* ipString); static char convertUCS2_2_gsm_char(char* ipString); static USHORT ATB_swap_bytes(USHORT character); /******************************************************************************* $Function: convertUCS2_2_ascii_char $Description: convert unicode char to ASCII char. Added for SPR 1508. moved here for SPR 2175 $Returns: ASCII char $Arguments: pointer to first byte of unicode char *******************************************************************************/ static char convertUCS2_2_ascii_char(char* ipString) { U16 word_code; BOOL match_found= FALSE; int k; char debug[60]; word_code = ipString[0]*0x100 + ipString[1]; sprintf(debug, "Word code: %d", word_code); TRACE_EVENT(debug); if (word_code <= 0xFF) if (translation_ascii_2_unicode[word_code] == word_code) return word_code; for (k=0; k < 256; k++) { if(translation_ascii_2_unicode[k] == word_code) { sprintf(debug, "Match found: %d, %d", word_code, k); TRACE_EVENT(debug); match_found = TRUE; /*a0393213 warnings removal-missing return statement-modified the flow*/ break; } } if (!match_found) { TRACE_EVENT("No match"); return 0x3F;/*question mark*/ } else { return k; } } /******************************************************************************* $Function: convertUCS2_2_ascii_char $Description: convert unicode char to GSM char. Added for SPR 1508. moved here for SPR 2175 $Returns: GSM char $Arguments: pointer to first byte of unicode char *******************************************************************************/ static char convertUCS2_2_gsm_char(char* ipString) { U16 word_code; BOOL match_found= FALSE; int k; word_code = ipString[0]*0x100 + ipString[1]; if ( word_code > 0x7F || g_translation_unicode[word_code] != word_code) { for (k=0; k < 128; k++) /*a0393213 lint warning:out-of-bounds soln:256 changed to 128*/ { if(g_translation_unicode[k] == word_code) { match_found = TRUE; break; } } } else return word_code; if (!match_found) { return '?'; } else { return k; } } /*a0393213(R.Prabakar) OMAPS00130278 - MS fails to display class 0 MT SMS when it contains alphanumeric and special characters.*/ /********************************************************* $Function : convertUnpacked7To8 $Description: This function converts the unpacked 7 bit encoded string to NULL terminated ASCII string. $Arguments : ipString - input string ipLength - length of input string opString - output string opLength - length of output string **********************************************************/ void convertUnpacked7To8 (char * ipString, int ipLength, char * opString, int opLength) { int index; for (index = 0; index < ipLength && index < (opLength-1); index++) { opString[index]= (char)g_translation_ascii_table[ipString[index]]; } /*null terminate the string*/ opString[index]='\0'; } /******************************************************************************* $Function: ATB_cvt7To8 $Description: This is a replacement for the ACI function utl_cvt7To8. utl_cvt7To8 cannot be used for output strings larger than 255 bytes, because it uses UBYTE values. ATB_cvt7To8 uses U16 values and overcomes this problem. $Arguments: Arguments are similar to utl_cvt7To8. source - Source string which is 7-bit GSM encoded. source_len - Length of source string in bytes. dest - Destination string, which will be 8-bit encoded. bit_offset - indicates which bit of the first byte is the boundary of the 7bits source. ex: for bit_offset = 3, bits 0-2 (low weight bits) will not be decoded *******************************************************************************/ /* xreddymn OMAPS00080543 Jun-06-2006 */ U16 ATB_cvt7To8 (const UBYTE* source, U16 source_len, UBYTE* dest, UBYTE bit_offset) { UBYTE d_mask = 0x01; UBYTE s_mask; U16 icnt; U16 ocnt; *dest = 0x00; icnt = source_len; if( !icnt ) return( 0 ); ocnt = 0; while (icnt) { s_mask = 0x01; if (icnt == source_len) s_mask <<= bit_offset; while (s_mask > 0x00) { if (s_mask & *source) *dest |= d_mask; s_mask <<= 1; d_mask <<= 1; if (d_mask > 0x40) { dest++; ocnt++; d_mask = 0x01; *dest = 0x00; } } source++; icnt--; } return( ocnt ); } /******************************************************************************* $Function: ATB_convert_String $Description: Convert a string into an ascii string with 0x80 as first word if data is unicode moved here and renamed for SPR 2175 $Returns: execution status $Arguments: ipString - input byte array ipDataType - type of input data ipLength - length of input string (in bytes) opString - output byte array opDataType - type of output data opLength - length of output string (in bytes) *******************************************************************************/ /* MC, SPR 1257, merged in b-sample version of this function*/ int ATB_convert_String( char * ipString, UBYTE ipDataType, int ipLength, char * opString, UBYTE opDataType, int opLength, UBYTE addNull) { int i;/*SPR 1946, changed from byte to int*/ int j;/*SPR 1946, changed from byte to int*/ /*JVJ SPR1298 Converted to dynamic variable */ UBYTE* text_8bit = NULL;/*SPR1991, don't alloacte this till it's needed*/ int len=0;/*SPR 1946, changed from byte to int*/ #ifdef TRACE_SMSREAD char buf[150]; sprintf(buf, "opString%x ipString%x ipLength%d opLength%d",opString, ipString, ipLength, opLength); TRACE_EVENT(buf); #endif if ((opString == NULL) || (ipString==NULL) || (opLength ==0)) return (FALSE); if (ipLength>MAX_STRING_LEN) { TRACE_EVENT("Too long, returning."); return FALSE; } opString[0] = 'X'; opString[1] = '?'; opString[2] = 0x00; #ifdef TRACE_SMSREAD sprintf(buf,"iDT: %d,iL:%d, oDT:%d, oL:%d, A0:%d",ipDataType,ipLength,opDataType,opLength,addNull); TRACE_EVENT(buf); #endif switch (ipDataType) { case MFW_DCS_UCS2: if (opDataType == MFW_DCS_UCS2) { //Copy array and add 0x80, 0x7F as first word if (ipLength < opLength) len = ipLength; else len = opLength; /*SPR 1507, copy the bytes in pairs*/ for (i=0;i<len;i+=2) { opString[i] = ipString[i]; opString[i+1] = ipString[i+1]; } if (i+1<opLength) { opString[i ] = 0x00; opString[i+1] = 0x00; } } else if ((opDataType == MFW_DCS_8bits) || (opDataType == MFW_ASCII)) { if ((ipLength/2 ) < opLength) len = ipLength/2; else len = opLength; for (i=0;i<len;i++) { /*SPR 1508, use new functions to convert to ASCII/GSM*/ if (opDataType == MFW_ASCII) opString[i] = convertUCS2_2_ascii_char(&ipString[i*2]); else opString[i] = convertUCS2_2_gsm_char(&ipString[i*2]); } if (len<opLength) { opString[len ] = 0x00; } } else //Output data type is 7 bits - not implemented { } break; case MFW_DCS_8bits: if (opDataType == MFW_DCS_UCS2) { //Convert data to unicode if (ipLength*2 < opLength) len = ipLength; else len = opLength/2; #ifdef TRACE_SMSREAD sprintf(buf, "8->UCS2, len:%d", len); TRACE_EVENT(buf); #endif for (i = 0; i < len; i++) { /*SPR 1508 use table to convert to Unicode*/ opString[i*2] = (g_translation_unicode[ipString[i]]>>8)&0x00FF; opString[i*2+1] = (g_translation_unicode[ipString[i]])&0x00FF; } if (len*2+1 < opLength) { opString[len*2] = 0x00; opString[len*2+1] = 0x00; } } else if (opDataType == MFW_DCS_8bits) { //Data already in correct format - copy if (ipLength < opLength) len = ipLength; else len = opLength; for (i=0;i<len;i++) { opString[i] = (char)g_translation_8bit_table[ipString[i]]; } if (len<opLength) opString[len] = 0x00; } else if (opDataType == MFW_ASCII) // SH - translate characters, don't change bit width { len = ipLength; if (len > opLength) len = opLength; for (i=0;i<len;i++) { opString[i] = (char)g_translation_8bit_table[ipString[i]]; } if (len<opLength) opString[len] = 0x00; //MMI_FIX-19656 Using 8 bit table for mapping end } else // convert data to 7bit { len = utl_cvt8To7 ((UBYTE *)ipString , ipLength, (UBYTE*)opString, 0); } break; case MFW_DCS_7bits: default: /*SPR 1991, allocate memory to conversion buffer*/ text_8bit = (UBYTE*)mfwAlloc(MAX_STRING_LEN+1); if (opDataType == MFW_DCS_7bits) //text string is already in this format { //Data already in correct format - copy if (ipLength < opLength) len = ipLength; else len = opLength; for (i=0;i<len;i++) opString[i] = ipString[i]; if (len<opLength) opString[len] = 0x00; } else if (opDataType == MFW_DCS_8bits) { /* xreddymn OMAPS00080543 Jun-06-2006 */ len = ATB_cvt7To8 ((UBYTE *)ipString , ipLength, (UBYTE *)opString, 0 ); if (len <opLength) opString[len] = 0x00; else opString[opLength]=0x00; } else if (opDataType == MFW_ASCII) // SH - expand to 8 bit and convert chars { /* xreddymn OMAPS00080543 Jun-06-2006 */ len = ATB_cvt7To8 ((UBYTE *)ipString , ipLength, text_8bit, 0 ); if (len > opLength) len = opLength; for (i = 0; i < len; i++) { opString[i] = (char)g_translation_ascii_table[UBYTEToChar(text_8bit[i])]; } if (len <opLength) opString[len] = 0x00; } else { //Convert to unicode /* xreddymn OMAPS00080543 Jun-06-2006 */ len = ATB_cvt7To8 ((UBYTE *)ipString , ipLength, text_8bit, 0); if (len*2 > opLength) len = opLength/2; for (i = 0; i < len; i++) {/*SPR 1508, use new table to convert to Unicode*/ opString[i*2] = (g_translation_unicode[ipString[i]]>>8)&0x00FF; opString[i*2+1] = g_translation_unicode[UBYTEToChar(text_8bit[i])]; } if (len*2+1 < opLength) { opString[len*2] = 0x00; opString[len*2+1] = 0x00; } } break; case MFW_ASCII: if (ipLength <=0) ipLength = strlen(ipString); //calculate length if not supplied if (opDataType == MFW_DCS_UCS2) { //Convert data to unicode if (ipLength*2 < opLength) len = ipLength; else len = opLength/2; for (i = 0; i < len; i++) { /*SPR 1508, convert to Unicode using new table*/ opString[i*2] = (translation_ascii_2_unicode[ ipString[i]]>>8)&0x00FF; opString[i*2+1] = (translation_ascii_2_unicode[ ipString[i]])&0x00FF; } if (len*2+1 < opLength) { opString[len*2] = 0x00; opString[len*2+1] = 0x00; } } else if (opDataType == MFW_ASCII) { //Data already in correct format - copy if (ipLength < opLength) len = ipLength; else len = opLength; for (i=0;i<len;i++) opString[i] = ipString[i]; if (len<opLength) opString[len] = 0x00; } else if (opDataType == MFW_DCS_8bits || opDataType == MFW_DCS_7bits) // SH - translate characters, don't change bit width { if (ipLength < opLength) len = ipLength; else len = opLength; for (i=0;i<len;i++) { opString[i] = ipString[i]; if ((unsigned char)(ipString[i])>=128 || g_translation_ascii_table[ipString[i]]!=(unsigned char)ipString[i]) { for (j=0; j<128; j++) // Reverse translation { if (ipString[i] == (char)g_translation_ascii_table[j]) opString[i] = j; } #ifdef TRACE_SMSREAD sprintf(buf, "Converted %x to %x", ipString[i], opString[i]); TRACE_EVENT(buf); #endif } } if (len<opLength) opString[len] = 0x00; } if (opDataType == MFW_DCS_7bits) // convert data to 7bit { len = utl_cvt8To7 ((UBYTE *)ipString , ipLength, (UBYTE*)opString, 0); } break; } if (addNull) { //Add 0x00 (or 0x00,0x00) to end of array /*SPR925 - SH - changed so NULL is in right place for unicode*/ if (opDataType == MFW_DCS_UCS2) { if (len*2+1>opLength) len = opLength/2; opString[len*2] = 0x00; opString[len*2+1] = 0x00; } else { if (len>opLength) len = opLength; opString[len] = 0x00; } /* end SPR925 */ } /*SPR 1991, free memory only if it has been allocated*/ if (text_8bit!= NULL) mfwFree(text_8bit,MAX_STRING_LEN+1); return TRUE; } /******************************************************************************* $Function: ATB_mem_Alloc $Description: ATB memory allocation function. $Returns: Address if successful, null if not. $Arguments: Size of memory to be allocated. *******************************************************************************/ UBYTE* ATB_mem_Alloc(USHORT size) { return (UBYTE *)mfwAlloc(size); } /******************************************************************************* $Function: ATB_mem_Free $Description: Frees memory allocated by the ATB $Returns: None. $Arguments: address - Pointer to memory to free size - Size of the allocated block *******************************************************************************/ void ATB_mem_Free(UBYTE* address, USHORT size) { mfwFree(address,size); return; } /******************************************************************************* $Function: ATB_swap_bytes $Description: Returns a unicode character with the bytes swapped. Added for SPR2175 $Returns: USHORT $Arguments: USHORT *******************************************************************************/ static USHORT ATB_swap_bytes(USHORT character) { return ((UNICODE_NONASCII&character) << 8) + ((UNICODE_ASCII&character) >>8); } /******************************************************************************* $Function: ATB_char_GSM $Description: Returns the GSM of the provided ascii character.Added for SPR 2175. $Returns: A GSM character $Arguments: character - The ascii character *******************************************************************************/ char ATB_char_GSM(char ascii_character) { int i; /*check if GSM and ASCII encoding are the same value*/ if (g_translation_ascii_table[ascii_character] == (unsigned char)ascii_character) return ascii_character; /*otherwise we have to search for the correct entry in the GSM to ASCII table*/ for (i=0; i<128; i++) { if (g_translation_ascii_table[i] == (unsigned char)ascii_character) return i; } return 0x3F;/*question mark*//*a0393213 warnings removal*/ } /******************************************************************************* $Function: ATB_char_Ascii $Description: Returns the ascii of the provided unicode character $Returns: An ascii character $Arguments: character - The unicode character *******************************************************************************/ char ATB_char_Ascii(USHORT character) { int i; /*SPR2175, rewrote function*/ /*if the first byte of the character is the same as the ASCII code, return the first byte*/ if (translation_ascii_2_unicode[((character & UNICODE_ASCII)>>8)] == ((character & UNICODE_ASCII)>>8)) return (char)((character & UNICODE_ASCII)>>8); /*otherwise we have to search for the correct entry in the ASCII to unicode table*/ for (i=0; i<256; i++) { if (translation_ascii_2_unicode[i] == ATB_swap_bytes(character)) return i; } return 0x3F;/*question mark*//*a0393213 warnings removal*/ } /******************************************************************************* $Function: ATB_char_Unicode $Description: Returns the unicode of the provided ascii character $Returns: A unicode character $Arguments: character - The ascii character *******************************************************************************/ USHORT ATB_char_Unicode(char character) { /*SPR 2175, re-wrote function*/ USHORT table_value; USHORT return_value = NULL; /*look up corresponding Unicode char in table*/ table_value= translation_ascii_2_unicode[character]; /*swap bytes as little-endian*/ return_value = ATB_swap_bytes(table_value); return return_value; } /******************************************************************************* $Function: ATB_char_IsAscii $Description: Returns TRUE if the unicode character provided is ascii $Returns: TRUE or FALSE $Arguments: character - The unicode character *******************************************************************************/ BOOL ATB_char_IsAscii(USHORT character) { BOOL result = FALSE; if (character & UNICODE_NONASCII) // Make sure character is ASCII { result = FALSE; } else { result = TRUE; } return result; } /******************************************************************************* $Function: ATB_char_IsAlphabetic $Description: Return TRUE if unicode character is part of latin alphabet $Returns: TRUE or FALSE $Arguments: character - The unicode character *******************************************************************************/ BOOL ATB_char_IsAlphabetic(USHORT character) { BOOL result = FALSE; UBYTE asciiChar; if (ATB_char_IsAscii(character)) // Make sure character is ASCII { asciiChar = ATB_char_Ascii(character); if ( (asciiChar >='A') && (asciiChar <='Z') ) result = TRUE; else if ( (asciiChar >='a') && (asciiChar <='z') ) result = TRUE; } return result; } /******************************************************************************* $Function: ATB_char_IsNumierc $Description: Return TRUE if unicode character is a digit, 0-9 $Returns: TRUE or FALSE $Arguments: character - The unicode character *******************************************************************************/ BOOL ATB_char_IsNumeric(USHORT character) { BOOL result = FALSE; UBYTE asciiChar; if (ATB_char_IsAscii(character)) // Make sure character is ASCII { asciiChar = ATB_char_Ascii(character); if ( (asciiChar >='0') && (asciiChar <='9') ) result = TRUE; } return result; } /******************************************************************************* $Function: ATB_char_IsVisible $Description: Return TRUE if unicode character is visible, i.e. not ascii <32 $Returns: TRUE or FALSE $Arguments: character - The unicode character *******************************************************************************/ BOOL ATB_char_IsVisible(USHORT character) { BOOL result = TRUE; UBYTE asciiChar; if (ATB_char_IsAscii(character)) // Make sure character is ASCII { asciiChar = ATB_char_Ascii(character); /*SPR 2175, if ASCII value has no unicode equivalent assume not visible*/ if (translation_ascii_2_unicode[asciiChar] == 0xFFFF) result = FALSE; } return result; } /******************************************************************************* $Function: ATB_string_Size $Description: Return the size in bytes of a character in the string $Returns: No. of bytes per character $Arguments: text - The text string *******************************************************************************/ UBYTE ATB_string_Size(T_ATB_TEXT *text) { UBYTE size; switch(text->dcs) { case ATB_DCS_UNICODE: size = 2; break; default: size = 1; break; } return size; } /******************************************************************************* $Function: ATB_string_SetChar $Description: Set a character in the string to a value. Use this function rather than accessing text data directly; it allows transparent ASCII and Unicode handling. $Returns: None $Arguments: text - The text string textIndex - The position of the character to set character - The unicode character to set it to *******************************************************************************/ void ATB_string_SetChar(T_ATB_TEXT *text, USHORT textIndex, USHORT character) { USHORT *unicode; //TISH modified for MSIM //Begin if (text->dcs==ATB_DCS_UNICODE) { unicode = (USHORT *)text->data; #ifdef WIN32 if(unicode[textIndex] != character) #endif unicode[textIndex] = character; } else { #ifdef WIN32 if(text->data[textIndex] != ATB_char_Ascii(character)) #endif text->data[textIndex] = ATB_char_Ascii(character); } //End return; } /******************************************************************************* $Function: ATB_string_GetChar $Description: Gets the value of a character in the string. Use this function rather than accessing text data directly; it allows transparent ASCII and Unicode handling. $Returns: The unicode character at the required position $Arguments: text - The text string textIndex - The position of the character to get *******************************************************************************/ USHORT ATB_string_GetChar(T_ATB_TEXT *text, USHORT textIndex) { USHORT *unicode; USHORT character; if (text->dcs==ATB_DCS_UNICODE) { unicode = (USHORT *)text->data; character = unicode[textIndex]; } else character = ATB_char_Unicode(text->data[textIndex]); return character; } /******************************************************************************* $Function: ATB_string_MoveLeft $Description: Move part of string left by 'offset' characters $Returns: TRUE if the operation was successful $Arguments: text - The text string textIndex - The place where the newly moved section is to go offset - The number of characters to move the section left by *******************************************************************************/ BOOL ATB_string_MoveLeft(T_ATB_TEXT *text, USHORT textIndex, USHORT offset) { BOOL outcome; USHORT character; /* Copy until end of line char reached */ while ((textIndex+offset)<=text->len) { character = ATB_string_GetChar(text, textIndex+offset); ATB_string_SetChar(text, textIndex, character); textIndex++; } outcome = TRUE; text->len -= offset; return outcome; } /******************************************************************************* $Function: ATB_string_MoveRight $Description: Move part of string right by 'offset' characters $Returns: TRUE if the operation was successful $Arguments: text - The text string textIndex - The start of the section to be moved right offset - The number of characters to move the section right by size - The maximum possible length of the string *******************************************************************************/ BOOL ATB_string_MoveRight(T_ATB_TEXT *text, USHORT textStart, USHORT offset, USHORT size) { int textIndex; BOOL outcome; USHORT character; textIndex = text->len; if ((text->len+ offset) < size) /* SPR#1995 - SH - <= should be < */ { while (textIndex >= textStart) { character = ATB_string_GetChar(text, textIndex); ATB_string_SetChar(text, textIndex+offset, character); textIndex--; } text->len += offset; outcome = TRUE; } else outcome = FALSE; return outcome; } /******************************************************************************* $Function: ATB_string_Length $Description: Returns the length of the string, also setting the 'len' parameter of the text structure $Returns: Length of the string in characters $Arguments: text - The text string *******************************************************************************/ USHORT ATB_string_Length(T_ATB_TEXT* text) { if (text->dcs==ATB_DCS_UNICODE) { text->len = ATB_string_UCLength((USHORT *)text->data); } else { text->len = strlen((char *)text->data); } return text->len; } /******************************************************************************* $Function: ATB_string_UCLength $Description: Returns the length of the provided unicode string $Returns: Length of the string in characters $Arguments: text - Pointer to the unicode string *******************************************************************************/ USHORT ATB_string_UCLength(USHORT* text) { USHORT length = 0; while (text[length]!=UNICODE_EOLN) { length++; } return (length); } /******************************************************************************* $Function: ATB_string_Copy $Description: Copy 'src' string into 'dest' string. $Returns: None. $Arguments: dest - The destination string (allocated by caller) src - The source string (allocated by caller) *******************************************************************************/ void ATB_string_Copy(T_ATB_TEXT* dest, T_ATB_TEXT* src) { USHORT textIndex; USHORT character; dest->dcs = src->dcs; for (textIndex=0; textIndex<src->len; textIndex++) { character = ATB_string_GetChar(src, textIndex); ATB_string_SetChar(dest, textIndex, character); } ATB_string_SetChar(dest, textIndex, UNICODE_EOLN); dest->len = textIndex; return; } /******************************************************************************* $Function: ATB_string_Concat $Description: Concatenate the second string, adding it to the end of the first. N.B. The strings don't have to have the same DCS. $Returns: None. $Arguments: dest - The destination string (allocated by caller) src - The source string (allocated by caller) *******************************************************************************/ void ATB_string_Concat(T_ATB_TEXT* dest, T_ATB_TEXT* src) { USHORT textIndex; USHORT character; TRACE_EVENT_P4("dest_len:%d, src len:%d, dest dcs: %d, src dcs:%d", dest->len, src->len, dest->dcs, src->dcs); for (textIndex = 0; textIndex<src->len; textIndex++) { character = ATB_string_GetChar(src, textIndex); /*SPR 2512, use destination length */ ATB_string_SetChar(dest, textIndex+dest->len, character); } dest->len += src->len; /*SPR 2512, use destination length to find point to insert termination*/ ATB_string_SetChar(dest, dest->len, UNICODE_EOLN); return; } /******************************************************************************* $Function: ATB_string_Concat $Description: Return position of character in string, or -1 if not found $Returns: Position of character in string $Arguments: text - The text string to search findChar - The character to find *******************************************************************************/ SHORT ATB_string_FindChar(T_ATB_TEXT* text, USHORT findChar) { USHORT textIndex; SHORT foundPos; USHORT character; textIndex = 0; foundPos = -1; character = ATB_string_GetChar(text, 0); while (character!=UNICODE_EOLN && foundPos==-1) { if (character==findChar) foundPos = (int)textIndex; textIndex++; character = ATB_string_GetChar(text, textIndex); } return foundPos; } /******************************************************************************* $Function: ATB_string_ToUnicode $Description: Convert a string to a unicode string. Memory for the unicode string should be allocated before calling. Returns a pointer to the unicode string. $Returns: None. $Arguments: dest - The destination string (allocated by caller) src - The source string (allocated by caller) *******************************************************************************/ void ATB_string_ToUnicode(T_ATB_TEXT *dest, T_ATB_TEXT *src) { USHORT textIndex; USHORT character; dest->dcs = ATB_DCS_UNICODE; for (textIndex=0; textIndex<src->len; textIndex++) { character = ATB_string_GetChar(src, textIndex); ATB_string_SetChar(dest, textIndex, character); } ATB_string_SetChar(dest, textIndex, UNICODE_EOLN); dest->len = textIndex; return; } /******************************************************************************* $Function: ATB_string_ToAscii $Description: Convert a string to an ascii string. Memory for the ascii string should be allocated before calling. Returns a pointer to the ascii string. $Returns: None. $Arguments: dest - The destination string (allocated by caller) src - The source string (allocated by caller) *******************************************************************************/ void ATB_string_ToAscii(T_ATB_TEXT *dest, T_ATB_TEXT *src) { USHORT textIndex; USHORT character; dest->dcs = ATB_DCS_ASCII; for (textIndex = 0; textIndex<src->len; textIndex++) { character = ATB_string_GetChar(src, textIndex); if (ATB_char_IsAscii(character) && ATB_char_IsVisible(character)) // Filter out non-ascii characters { character = ATB_char_Unicode('?'); } ATB_string_SetChar(dest, textIndex, character); } return; } /******************************************************************************* $Function: ATB_string_ToUnicode $Description: Moves index position through text $Returns: The new index. $Arguments: text - The text string textIndex - Current position within the text buffer offset - Negative for backwards movement, positive for forwards movement. *******************************************************************************/ USHORT ATB_string_IndexMove(T_ATB_TEXT *text, USHORT textIndex, SHORT offset) { while (textIndex>0 && offset<0) { textIndex--; offset++; } while (ATB_string_GetChar(text, textIndex)!=UNICODE_EOLN && offset>0) { textIndex++; offset--; } return textIndex; }