开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > MTK > 查看源码
GSM7BitDefaultAlphabet.c
资源名称：mmi.rar　[点击查看]
上传用户：lqx1163
上传日期：2014-08-13
资源大小：9183k
文件大小：47k
源码类别：

MTK

开发平台：

C/C++

GSM7BitDefaultAlphabet.c：源码内容
  1. /*****************************************************************************
  2. *  Copyright Statement:
  3. *  --------------------
  4. *  This software is protected by Copyright and the information contained
  5. *  herein is confidential. The software may not be copied and the information
  6. *  contained herein may not be used or disclosed except with the written
  7. *  permission of MediaTek Inc. (C) 2005
  8. *
  9. *  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  10. *  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  11. *  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
  12. *  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  13. *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  14. *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  15. *  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  16. *  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  17. *  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
  18. *  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
  19. *  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
  20. *  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
  21. *
  22. *  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
  23. *  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  24. *  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  25. *  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
  26. *  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. 
  27. *
  28. *  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
  29. *  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
  30. *  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
  31. *  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
  32. *  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
  33. *
  34. *****************************************************************************/
  36. /*******************************************************************************
  37.  * Filename:
  38.  * ---------
  39.  *  GSM7BitDefaultAlphabet.c
  40.  *
  41.  * Project:
  42.  * --------
  43.  *  MAUI
  44.  *
  45.  * Description:
  46.  * ------------
  47.  *  
  48.  *
  49.  * Author:
  50.  * -------
  51.  *  
  52.  *
  53.  *==============================================================================
  54.  *             HISTORY
  55.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!! 
  56.  *------------------------------------------------------------------------------
  57.  * removed!
  58.  *
  59.  * removed!
  60.  * removed!
  61.  * removed!
  62.  *
  63.  * removed!
  64.  * removed!
  65.  * removed!
  66.  *
  67.  * removed!
  68.  * removed!
  69.  * removed!
  70.  *
  71.  * removed!
  72.  * removed!
  73.  * removed!
  74.  *
  75.  * removed!
  76.  * removed!
  77.  * removed!
  78.  *
  79.  * removed!
  80.  * removed!
  81.  * removed!
  82.  *
  83.  * removed!
  84.  * removed!
  85.  * removed!
  86.  *
  87.  *------------------------------------------------------------------------------
  88.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!! 
  89.  *==============================================================================
  90.  *******************************************************************************/
  92. /**
  93.  * Copyright Notice
  94.  * ?2002 - 2003, Pixtel Communications, Inc., 1489 43rd Ave. W.,
  95.  * Vancouver, B.C. V6M 4K8 Canada. All Rights Reserved.
  96.  *  (It is illegal to remove this copyright notice from this software or any
  97.  *  portion of it)
  98.  */
  99. /**************************************************************
  101.    FILENAME : GSM7BitDefaultAlphabet.c
  103.    PURPOSE     : Converts GSM 7-bit Default alphabet to ascii and
  104.                Ascii to GSM 7-bit Default alphabet
  106.    REMARKS     : .
  108.    AUTHOR      : .
  110.    DATE     : 11-07-03
  112. **************************************************************/
  114. #include "stdC.h"
  115. #include "PixtelDataTypes.h"
  116. #include "GSM7BitDefaultAlphabet.h"
  117. #include "unicodexdcl.h"
  119. /* micha1018 */
  120. #include "wgui_categories.h"
  122. #ifndef GSM_7BIT_DEFAULT_ALPHABET_DEBUG
  123. #undef PRINT_INFORMATION
  124. #define PRINT_INFORMATION(args) NULL
  125. #endif /* GSM_7BIT_DEFAULT_ALPHABET_DEBUG */ 
  127. #define SWAP_SHORT(Var)  *Var = *(short*)         SwapEndian((void*)Var, sizeof(short))
  128. #define SWAP_USHORT(Var) *Var = *(unsigned short*)SwapEndian((void*)Var, sizeof(short))
  129. #define SWAP_LONG(Var)   *Var = *(long*)          SwapEndian((void*)Var, sizeof(long))
  130. #define SWAP_ULONG(Var)  *Var = *(unsigned long*) SwapEndian((void*)Var, sizeof(long))
  131. #define SWAP_FLOAT(Var)  *Var = *(float*)         SwapEndian((void*)Var, sizeof(float))
  132. #define SWAP_DOUBLE(Var) *Var = *(double*)        SwapEndian((void*)Var, sizeof(double))
  134. #define UI_GET_NEXT_BYTE(p,c)          
  135. {  c=(*p);                             
  136.    p+=1;                               
  137. }
  139. #define UI_GET_PREVIOUS_BYTE(p,c)         
  140. {  p-=1;                                  
  141.    c=(*p);                                
  142. }
  144. #define UI_INSERT_BYTE(p,c)               
  145. {  (*((p))++)=(U8)(c);                    
  146. }
  148. #define UI_SWAP_U16_BYTES(c) (c)=((c)>>8)|((c)<<8)
  150. #define _EURO_CHARACTER_UCS2     (0x20AC)
  151. #define _EURO_CHARACTER          (0xA2)
  152. #define _ESCAPE_CHARACTER        (27)
  153. #define _SPACE_CHARACTER         (32)
  155. extern const U8 AsciiToDefaultArray[];
  156. extern const U8 ExtendedAsciiToDefaultArray[];
  157. extern const U8 DefaultToExtendedAsciiArray[];
  158. extern const U8 DefaultToAsciiArray[];
  161. const U8 DefaultToAsciiArray[128] = 
  162. {
  163.     64, 163, 36, 165, 232, 233, 249, 236, 242, 199,
  164.     10, 216, 248, 13, 197, 229, 16, 95, 18, 19,
  165.     20, 21, 22, 23, 24, 25, 26, 27, 198, 230,
  166.     223, 200, 32, 33, 34, 35, 164, 37, 38, 39,
  167.     40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
  168.     50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
  169.     60, 61, 62, 63, 161, 65, 66, 67, 68, 69,
  170.     70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
  171.     80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
  172.     90, 196, 214, 209, 220, 167, 191, 97, 98, 99,
  173.     100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
  174.     110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
  175.     120, 121, 122, 228, 246, 241, 252, 224
  176. };
  178. const U8 DefaultToExtendedAsciiArray[128] = 
  179. {
  180.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  181.     32, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /* Page Break at 10=32 Change Later */
  182.     94, 0, 0, 0, 0, 0, 0, 32, 0, 0,
  183.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  184.     123, 125, 0, 0, 0, 0, 0, 92, 0, 0,
  185.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  186.     91, 126, 93, 0, 124, 0, 0, 0, 0, 0,
  187.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  188.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  189.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  190.     0, 162, 0, 0, 0, 0, 0, 0, 0, 0, /* Euro character at 101 changed to 162 */
  191.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  192.     0, 0, 0, 0, 0, 0, 0, 0
  193. };
  195. const U8 AsciiToDefaultArray[] = 
  196. {
  197.     32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
  198.     10, 32, 32, 13, 32, 32, 16, 32, 18, 19,
  199.     20, 21, 22, 23, 24, 25, 26, 27, 32, 32,
  200.     32, 32, 32, 33, 34, 35, 2, 37, 38, 39,
  201.     40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
  202.     50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
  203.     60, 61, 62, 63, 0, 65, 66, 67, 68, 69,
  204.     70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
  205.     80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
  206.     90, 32, 32, 32, 32, 17, 32, 97, 98, 99,
  207.     100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
  208.     110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
  209.     120, 121, 122, 32, 32, 32, 32, 32, 32, 32,
  210.     32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
  211.     32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
  212.     32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
  213.     32, 64, 32, 1, 36, 3, 32, 95, 32, 32,
  214.     32, 32, 32, 64, 32, 32, 32, 32, 32, 32,
  215.     32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
  216.     32, 96, 32, 32, 32, 32, 91, 14, 28, 9,
  217.     31, 32, 32, 32, 32, 32, 32, 32, 32, 93,
  218.     32, 32, 32, 32, 92, 32, 11, 32, 32, 32,
  219.     94, 32, 32, 30, 127, 32, 32, 32, 123, 15,
  220.     29, 32, 4, 5, 32, 32, 7, 32, 32, 32,
  221.     32, 125, 8, 32, 32, 32, 124, 32, 12, 6,
  222.     32, 32, 126, 32, 32, 32
  223. };
  225. const U8 ExtendedAsciiToDefaultArray[] = 
  226. {
  227.     0, 32, 32, 32, 32, 32, 32, 32, 32, 32,
  228.     32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
  229.     32, 32, 32, 32, 32, 32, 32, 27, 32, 32,
  230.     32, 32, 10, 32, 32, 32, 32, 32, 32, 32,
  231.     32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
  232.     32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
  233.     32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
  234.     32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
  235.     32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
  236.     32, 60, 47, 62, 20, 32, 32, 32, 32, 32,
  237.     32, 101, 32, 32, 32, 32, 32, 32, 32, 32,
  238.     32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
  239.     32, 32, 32, 40, 64, 41, 61, 32, 32, 32,
  240.     32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
  241.     32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
  242.     32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
  243.     32, 32, 101, 32, 32, 32, 32, 32, 32, 32,    /* Changed character at 162 to 101 (old value was 32) */
  244.     32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
  245.     32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
  246.     32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
  247.     32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
  248.     32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
  249.     32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
  250.     32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
  251.     32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
  252.     32, 32, 32, 32, 32, 32
  253. };
  256. /*****************************************************************************
  257.  * FUNCTION
  258.  *  ConvertGSM7BitDefaultEncodingToAscii
  259.  * DESCRIPTION
  260.  *  Converts 7 bit encoding to 8 bit Ascii
  261.  * PARAMETERS
  262.  *  message     [IN]        Output Buffer
  263.  *  msg         [IN]        Input Buffer
  264.  *  length      [IN]        No of bytes to be converted
  265.  *  outLen      [?]         
  266.  * RETURNS
  267.  *  void
  268.  *****************************************************************************/
  269. void ConvertGSM7BitDefaultEncodingToAscii(U8 *message, U8 *msg, U16 length, U16 *outLen)
  270. {
  271.     /*----------------------------------------------------------------*/
  272.     /* Local Variables                                                */
  273.     /*----------------------------------------------------------------*/
  274.     U16 i, j = 0;
  276.     /*----------------------------------------------------------------*/
  277.     /* Code Body                                                      */
  278.     /*----------------------------------------------------------------*/
  279.     for (i = 0; i < length; i++)
  280.     {
  281.         if (msg[i] != 27)   /* escape char ? */
  282.         {
  283.             /* if(msg[i]!=13)       //CR ? */
  284.             message[j++] = DefaultToAsciiArray[msg[i]];
  285.         }
  286.         else
  287.         {
  288.             /* treat escape char as a space */
  289.             message[j++] = 32;
  290.         }
  291.     }
  292.     if (outLen != NULL)
  293.     {
  294.         *outLen = j;
  295.     }
  296. }
  299. /*****************************************************************************
  300.  * FUNCTION
  301.  *  GSM7BitMapDefaultToASCIIByte
  302.  * DESCRIPTION
  303.  *  Converts 7 bit encoding to 8 bit Ascii
  304.  * PARAMETERS
  305.  *  input       [IN]        (GSM 7 bit encoded value)
  306.  *  none(?)     [OUT]       
  307.  * RETURNS
  308.  *  U8 (ASCII value)
  309.  *****************************************************************************/
  310. U8 GSM7BitMapDefaultToASCIIByte(U8 input)
  311. {
  312.     /*----------------------------------------------------------------*/
  313.     /* Local Variables                                                */
  314.     /*----------------------------------------------------------------*/
  316.     /*----------------------------------------------------------------*/
  317.     /* Code Body                                                      */
  318.     /*----------------------------------------------------------------*/
  319.     if (input == 27)
  320.     {
  321.         return 32;  /* return space for "Escape" */
  322.     }
  323.     if (input == 13)
  324.     {
  325.         return 13;  /* Returning same value, but UI should skip CR */
  326.     }
  327.     return DefaultToAsciiArray[input];  /* use the table for the rest */
  328. }
  331. /*****************************************************************************
  332.  * FUNCTION
  333.  *  GSM7BitMapASCIIToDefaultByte
  334.  * DESCRIPTION
  335.  *  Converts  8 bit Ascii to 7 bit encoding
  336.  * PARAMETERS
  337.  *  input       [IN]        (ASCII value)
  338.  *  none(?)     [OUT]       
  339.  * RETURNS
  340.  *  U8 (GSM 7 bit encoded value)
  341.  *****************************************************************************/
  342. U8 GSM7BitMapASCIIToDefaultByte(U8 input)
  343. {
  344.     /*----------------------------------------------------------------*/
  345.     /* Local Variables                                                */
  346.     /*----------------------------------------------------------------*/
  348.     /*----------------------------------------------------------------*/
  349.     /* Code Body                                                      */
  350.     /*----------------------------------------------------------------*/
  351.     return AsciiToDefaultArray[input];
  352. }
  355. /*****************************************************************************
  356.  * FUNCTION
  357.  *  ConvertAsciiEncodingToGSM7BitDefault
  358.  * DESCRIPTION
  359.  *  Converts  8 bit Ascii to 7 bit encoding
  360.  * PARAMETERS
  361.  *  message     [IN]        Output Buffer
  362.  *  msg         [IN]        Input Buffer
  363.  *  length      [IN]        No of bytes to be converted
  364.  *  outLen      [?]         
  365.  * RETURNS
  366.  *  void
  367.  *****************************************************************************/
  368. void ConvertAsciiEncodingToGSM7BitDefault(U8 *message, U8 *msg, U16 length, U16 *outLen)
  369. {
  370.     /*----------------------------------------------------------------*/
  371.     /* Local Variables                                                */
  372.     /*----------------------------------------------------------------*/
  373.     U16 i, j;
  375.     /*----------------------------------------------------------------*/
  376.     /* Code Body                                                      */
  377.     /*----------------------------------------------------------------*/
  378.     for (i = 0, j = 0; i < length; i++, j++)
  379.     {
  380.         message[j] = AsciiToDefaultArray[msg[i]];
  381.     }
  382.     if (outLen != NULL)
  383.     {
  384.         *outLen = j;
  385.     }
  386. }
  388. #ifndef OSL_MEMORY_DUMP
  391. /*****************************************************************************
  392.  * FUNCTION
  393.  *  CovertStringForSIM
  394.  * DESCRIPTION
  395.  *  Converts data from Platfrorm (ASCII or UCS2) format to one specified
  396.  * PARAMETERS
  397.  *  data            [IN]        Pointer to dat to be converted
  398.  *  len             [IN]        No of bytes to be converted
  399.  *  format          [IN]        Format to which data is to be converted 7 bit. 8 bit or UCS2
  400.  *  outLen          [?]         
  401.  *  outlen(?)       [OUT]       Pointer in which output length will be returned
  402.  * RETURNS
  403.  *  Pointer to data containing converted data
  404.  *****************************************************************************/
  405. U8 *CovertStringForSIM(U8 *data, U16 len, U8 format, U16 *outLen)
  406. {
  407.     /*----------------------------------------------------------------*/
  408.     /* Local Variables                                                */
  409.     /*----------------------------------------------------------------*/
  410.     U8 *convertedData = NULL;
  411.     U16 outLength;
  413.     /*----------------------------------------------------------------*/
  414.     /* Code Body                                                      */
  415.     /*----------------------------------------------------------------*/
  416.     if (len > 0)
  417.     {
  418.         switch (format)
  419.         {
  420.             case MMI_DEFAULT_DCS:
  421.                 {
  422.                     U8 *tempData;
  424.                     convertedData = OslMalloc((len) + 1);
  425.                     tempData = OslMalloc(len);
  426.                     UnicodeNToAnsii((PS8) tempData, (PS8) data, len);
  427.                     ConvertAsciiEncodingToGSM7BitDefault(
  428.                         convertedData,
  429.                         tempData,
  430.                         (U16) (len / ENCODING_LENGTH),
  431.                         &outLength);
  432.                     OslMfree(tempData);
  433.                     convertedData[outLength] = 0;
  434.                     if (outLen != NULL)
  435.                     {
  436.                         *outLen = outLength + 1;
  437.                     }
  438.                 }
  439.                 break;
  441.             case MMI_8BIT_DCS:
  442.                 convertedData = OslMalloc((len / ENCODING_LENGTH) + 1);
  443.                 UnicodeNToAnsii((PS8) convertedData, (PS8) data, len);
  444.                 memset((void*)&convertedData[len / ENCODING_LENGTH], 0, 1);
  445.                 if (outLen != NULL)
  446.                 {
  447.                     *outLen = len / ENCODING_LENGTH + 1;
  448.                 }
  449.                 break;
  451.             case MMI_UCS2_DCS:
  452.                 convertedData = OslMalloc((len) + ENCODING_LENGTH);
  453.                 memcpy(convertedData, data, len);
  454.                 memset((void*)&convertedData[len], 0, ENCODING_LENGTH);
  455.                 if (outLen != NULL)
  456.                 {
  457.                     *outLen = len + ENCODING_LENGTH;
  458.                 }
  459.             #ifdef MMI_ON_HARDWARE_P
  460.                 {
  461.                     U16 *tempData;
  462.                     int i;
  464.                     tempData = (U16*) convertedData;
  465.                     for (i = 0; i < len * 2 / ENCODING_LENGTH; i += 2)
  466.                     {
  467.                         SWAP_USHORT(tempData);
  468.                         tempData++;
  469.                     }
  470.                 }
  471.             #endif /* MMI_ON_HARDWARE_P */ 
  472.                 break;
  473.         }
  475.         return convertedData;
  476.     }
  477.     else
  478.     {
  479.         U8 noOfNulls;
  481.         if (format == MMI_UCS2_DCS)
  482.         {
  483.             noOfNulls = 2;
  484.         }
  485.         else
  486.         {
  487.             noOfNulls = 1;
  488.         }
  489.         convertedData = OslMalloc(noOfNulls);
  490.         memset((void*)convertedData, 0, noOfNulls);
  491.         if (outLen != NULL)
  492.         {
  493.             *outLen = noOfNulls;
  494.         }
  495.         return convertedData;
  496.     }
  497. }
  500. /*****************************************************************************
  501.  * FUNCTION
  502.  *  CovertStringForPlatform
  503.  * DESCRIPTION
  504.  *  Converts data from specified format to Platform type (UCS2 or ASCII)
  505.  * PARAMETERS
  506.  *  data            [IN]        Pointer to data to be converted
  507.  *  len             [IN]        No of bytes to be converted
  508.  *  format          [IN]        Format of input data
  509.  *  outLen          [?]         
  510.  *  outlen(?)       [OUT]       Pointer in which output length will be returned
  511.  * RETURNS
  512.  *  Pointer to data containing converted data
  513.  *****************************************************************************/
  514. U8 *CovertStringForPlatform(U8 *data, U16 len, U8 format, U16 *outLen)
  515. {
  516.     /*----------------------------------------------------------------*/
  517.     /* Local Variables                                                */
  518.     /*----------------------------------------------------------------*/
  519.     /* MTK JL added for init */
  520.     U8 *convertedData = NULL;
  522.     /* MTK end */
  523.     U16 outLength;
  525.     /*----------------------------------------------------------------*/
  526.     /* Code Body                                                      */
  527.     /*----------------------------------------------------------------*/
  528.     if (len > 0)
  529.     {
  530.         switch (format)
  531.         {
  532.             case (MMI_DEFAULT_DCS):
  533.                 {
  534.                     U8 *tempData;
  535.     
  536.                     convertedData = OslMalloc((len * ENCODING_LENGTH) + ENCODING_LENGTH);
  537.                     tempData = OslMalloc(len);
  538.                     ConvertGSM7BitDefaultEncodingToAscii(tempData, data, len, &outLength);
  539.                     AnsiiNToUnicodeString((PS8) convertedData, (PS8) tempData, outLength);
  540.                     memset((void*)&convertedData[outLength * ENCODING_LENGTH], 0, ENCODING_LENGTH);
  541.                     OslMfree(tempData);
  542.                 }
  543.                 if (outLen != NULL)
  544.                 {
  545.                     *outLen = outLength * ENCODING_LENGTH + ENCODING_LENGTH;
  546.                 }
  547.                 break;
  549.             case (MMI_8BIT_DCS):
  550.                 convertedData = OslMalloc((len * ENCODING_LENGTH) + ENCODING_LENGTH);
  551.                 AnsiiNToUnicodeString((PS8) convertedData, (PS8) data, len);
  552.                 memset((void*)&convertedData[len * ENCODING_LENGTH], 0, ENCODING_LENGTH);
  553.                 if (outLen != NULL)
  554.                 {
  555.                     *outLen = len * ENCODING_LENGTH + ENCODING_LENGTH;
  556.                 }
  557.                 break;
  559.             case (MMI_UCS2_DCS):
  560.                 convertedData = OslMalloc(len + 1 + ENCODING_LENGTH);   /* prevent odd len number */
  561.                 memset((void*)convertedData, 0, len + 1 + ENCODING_LENGTH);
  562.                 memcpy(convertedData, data, len);
  563.                 if (outLen != NULL)
  564.                 {
  565.                     *outLen = len + ENCODING_LENGTH;
  566.                 }
  568.             #ifdef MMI_ON_HARDWARE_P
  569.                 {
  570.                     U16 *tempData;
  571.                     int i;
  573.                     /* micha0902, #124 */
  574.                     tempData = (U16*) convertedData;
  575.                     for (i = 0; i < len; i += 2)
  576.                     {
  577.                         SWAP_USHORT(tempData);
  578.                         tempData++;
  579.                     }
  580.                 }
  581.             #endif /* MMI_ON_HARDWARE_P */ 
  582.                 break;
  584.                 /* micha1008 begin */
  585.             case (MMI_UCS2_81):
  586.                 convertedData = OslMalloc((len + 1) * 2 + ENCODING_LENGTH);     /* prevent odd len number */
  587.                 memset((void*)convertedData, 0, (len + 1) * 2 + ENCODING_LENGTH);
  589.                 InputboxConvertGSMToDeviceEncoding(
  590.                     data,
  591.                     convertedData,
  592.                     (U8) len,
  593.                     (len + 1) * 2 + ENCODING_LENGTH,
  594.                     MMI_UCS2_81,
  595.                     0,
  596.                     1);
  597.                 break;
  599.             case (MMI_UCS2_82):
  600.                 convertedData = OslMalloc((len + 1) * 2 + ENCODING_LENGTH);     /* prevent odd len number */
  601.                 memset((void*)convertedData, 0, (len + 1) * 2 + ENCODING_LENGTH);
  603.                 InputboxConvertGSMToDeviceEncoding(
  604.                     data,
  605.                     convertedData,
  606.                     (U8) len,
  607.                     (len + 1) * 2 + ENCODING_LENGTH,
  608.                     MMI_UCS2_82,
  609.                     0,
  610.                     1);
  611.                 break;
  612.                 /* micha1008 end */
  614.         }
  615.         return convertedData;
  616.     }
  617.     else
  618.     {
  619.         convertedData = OslMalloc(ENCODING_LENGTH);
  620.         memset((void*)convertedData, 0, ENCODING_LENGTH);
  621.         if (outLen != NULL)
  622.         {
  623.             *outLen = ENCODING_LENGTH;
  624.         }
  625.         return convertedData;
  626.     }
  627. }
  628. #else /* OSL_MEMORY_DUMP */ 
  631. /*****************************************************************************
  632.  * FUNCTION
  633.  *  CovertStringForSIMInt
  634.  * DESCRIPTION
  635.  *  Converts data from Platfrorm (ASCII or UCS2) format to one specified
  636.  * PARAMETERS
  637.  *  data            [IN]        Pointer to dat to be converted
  638.  *  len             [IN]        No of bytes to be converted
  639.  *  format          [IN]        Format to which data is to be converted 7 bit. 8 bit or UCS2
  640.  *  outLen          [?]         
  641.  *  fileName        [?]         
  642.  *  lineNumber      [IN]        
  643.  *  outlen(?)       [OUT]       Pointer in which output length will be returned
  644.  * RETURNS
  645.  *  Pointer to data containing converted data
  646.  *****************************************************************************/
  647. U8 *CovertStringForSIMInt(U8 *data, U16 len, U8 format, U16 *outLen, S8 *fileName, S32 lineNumber)
  648. {
  649.     /*----------------------------------------------------------------*/
  650.     /* Local Variables                                                */
  651.     /*----------------------------------------------------------------*/
  652.     U8 *convertedData;
  653.     U16 outLength;
  655.     /*----------------------------------------------------------------*/
  656.     /* Code Body                                                      */
  657.     /*----------------------------------------------------------------*/
  658.     if (len > 0)
  659.     {
  660.         switch (format)
  661.         {
  662.             case MMI_DEFAULT_DCS:
  663.                 {
  664.                     U8 *tempData;
  666.                     convertedData = OslMallocCHK((len) + 1, fileName, lineNumber);
  667.                     tempData = OslMallocCHK(len, fileName, lineNumber);
  668.                     UnicodeNToAnsii((PS8) tempData, (PS8) data, len);
  669.                     ConvertAsciiEncodingToGSM7BitDefault(
  670.                         convertedData,
  671.                         tempData,
  672.                         (U16) (len / ENCODING_LENGTH),
  673.                         &outLength);
  674.                     OslMfree(tempData);
  675.                     convertedData[outLength] = 0;
  676.                     if (outLen != NULL)
  677.                     {
  678.                         *outLen = outLength + 1;
  679.                     }
  680.                 }
  681.                 break;
  683.             case MMI_8BIT_DCS:
  684.                 convertedData = OslMallocCHK((len / ENCODING_LENGTH) + 1, fileName, lineNumber);
  685.                 UnicodeNToAnsii((PS8) convertedData, (PS8) data, len);
  686.                 memset((void*)&convertedData[len / ENCODING_LENGTH], 0, 1);
  687.                 if (outLen != NULL)
  688.                 {
  689.                     *outLen = len / ENCODING_LENGTH + 1;
  690.                 }
  691.                 break;
  693.             case MMI_UCS2_DCS:
  694.                 convertedData = OslMallocCHK((len) + ENCODING_LENGTH, fileName, lineNumber);
  695.                 memcpy(convertedData, data, len);
  696.                 memset((void*)&convertedData[len], 0, ENCODING_LENGTH);
  697.                 if (outLen != NULL)
  698.                 {
  699.                     *outLen = len + ENCODING_LENGTH;
  700.                 }
  701.             #ifdef MMI_ON_HARDWARE_P
  702.                 {
  703.                     U16 *tempData;
  704.                     int i;
  706.                     tempData = (U16*) convertedData;
  707.                     for (i = 0; i < len * 2 / ENCODING_LENGTH; i += 2)
  708.                     {
  709.                         SWAP_USHORT(tempData);
  710.                         tempData++;
  711.                     }
  712.                 }
  713.             #endif /* MMI_ON_HARDWARE_P */ 
  714.                 break;
  715.         }
  717.         return convertedData;
  718.     }
  719.     else
  720.     {
  721.         U8 noOfNulls;
  723.         if (format == MMI_UCS2_DCS)
  724.         {
  725.             noOfNulls = 2;
  726.         }
  727.         else
  728.         {
  729.             noOfNulls = 1;
  730.         }
  731.         convertedData = OslMallocCHK(noOfNulls, fileName, lineNumber);
  732.         memset((void*)convertedData, 0, noOfNulls);
  733.         if (outLen != NULL)
  734.         {
  735.             *outLen = noOfNulls;
  736.         }
  737.         return convertedData;
  738.     }
  739. }
  742. /*****************************************************************************
  743.  * FUNCTION
  744.  *  CovertStringForPlatformInt
  745.  * DESCRIPTION
  746.  *  Converts data from specified format to Platform type (UCS2 or ASCII)
  747.  * PARAMETERS
  748.  *  data            [IN]        Pointer to data to be converted
  749.  *  len             [IN]        No of bytes to be converted
  750.  *  format          [IN]        Format of input data
  751.  *  outLen          [?]         
  752.  *  fileName        [?]         
  753.  *  lineNumber      [IN]        
  754.  *  outlen(?)       [OUT]       Pointer in which output length will be returned
  755.  * RETURNS
  756.  *  Pointer to data containing converted data
  757.  *****************************************************************************/
  758. U8 *CovertStringForPlatformInt(U8 *data, U16 len, U8 format, U16 *outLen, S8 *fileName, S32 lineNumber)
  759. {
  760.     /*----------------------------------------------------------------*/
  761.     /* Local Variables                                                */
  762.     /*----------------------------------------------------------------*/
  763.     U8 *convertedData;
  764.     U16 outLength;
  766.     /*----------------------------------------------------------------*/
  767.     /* Code Body                                                      */
  768.     /*----------------------------------------------------------------*/
  769.     if (len > 0)
  770.     {
  771.         switch (format)
  772.         {
  773.             case (MMI_DEFAULT_DCS):
  774.                 {
  775.                     U8 *tempData;
  776.     
  777.                     convertedData = OslMallocCHK((len * ENCODING_LENGTH) + ENCODING_LENGTH, fileName, lineNumber);
  778.                     tempData = OslMallocCHK(len, fileName, lineNumber);
  779.                     ConvertGSM7BitDefaultEncodingToAscii(tempData, data, len, &outLength);
  780.                     AnsiiNToUnicodeString((PS8) convertedData, (PS8) tempData, outLength);
  781.                     memset((void*)&convertedData[outLength * ENCODING_LENGTH], 0, ENCODING_LENGTH);
  782.                     OslMfree(tempData);
  783.                 }
  784.                 if (outLen != NULL)
  785.                 {
  786.                     *outLen = outLength * ENCODING_LENGTH + ENCODING_LENGTH;
  787.                 }
  788.                 break;
  790.             case (MMI_8BIT_DCS):
  791.                 convertedData = OslMallocCHK((len * ENCODING_LENGTH) + ENCODING_LENGTH, fileName, lineNumber);
  792.                 AnsiiNToUnicodeString((PS8) convertedData, (PS8) data, len);
  793.                 memset((void*)&convertedData[len * ENCODING_LENGTH], 0, ENCODING_LENGTH);
  794.                 if (outLen != NULL)
  795.                 {
  796.                     *outLen = len * ENCODING_LENGTH + ENCODING_LENGTH;
  797.                 }
  798.                 break;
  800.             case (MMI_UCS2_DCS):
  801.                 convertedData = OslMallocCHK(len + ENCODING_LENGTH, fileName, lineNumber);
  802.                 memcpy(convertedData, data, len);
  803.                 memset((void*)&convertedData[len], 0, ENCODING_LENGTH);
  804.                 if (outLen != NULL)
  805.                 {
  806.                     *outLen = len + ENCODING_LENGTH;
  807.                 }
  808.             #ifdef MMI_ON_HARDWARE_P
  809.                 {
  810.                     U16 *tempData;
  811.                     int i;
  813.                     /* micha0902, #124 */
  814.                     tempData = (U16*) convertedData;
  815.                     for (i = 0; i < len; i += 2)
  816.                     {
  817.                         SWAP_USHORT(tempData);
  818.                         tempData++;
  819.                     }
  820.                 }
  821.             #endif /* MMI_ON_HARDWARE_P */ 
  823.                 break;
  825.         }
  826.         return convertedData;
  827.     }
  828.     else
  829.     {
  830.         convertedData = OslMallocCHK(ENCODING_LENGTH, fileName, lineNumber);
  831.         memset((void*)convertedData, 0, ENCODING_LENGTH);
  832.         if (outLen != NULL)
  833.         {
  834.             *outLen = ENCODING_LENGTH;
  835.         }
  836.         return convertedData;
  837.     }
  838. }
  839. #endif /* OSL_MEMORY_DUMP */ 
  842. /*****************************************************************************
  843.  * FUNCTION
  844.  *  ConvertBCDToString
  845.  * DESCRIPTION
  846.  *  Converts  BCD Digits to Character String
  847.  * PARAMETERS
  848.  *  BCDNumber       [?]         
  849.  *  len             [IN]        
  850.  *  outLen          [?]         
  851.  *  of(?)           [OUT]       Character String  will be returned
  852.  *  msg(?)          [IN]        Input Buffer
  853.  *  message(?)      [IN]        Output Buffer
  854.  *  outlen(?)       [OUT]       Pointer to variable which will have output length
  855.  * RETURNS
  856.  *  Character String of BCD Characters
  857.  *****************************************************************************/
  858. U8 *ConvertBCDToString(U8 *BCDNumber, U16 len, U16 *outLen)
  859. {
  860.     /*----------------------------------------------------------------*/
  861.     /* Local Variables                                                */
  862.     /*----------------------------------------------------------------*/
  863.     U8 *outString;
  864.     U8 i, j = 0;
  866.     /*----------------------------------------------------------------*/
  867.     /* Code Body                                                      */
  868.     /*----------------------------------------------------------------*/
  869.     outString = OslMalloc(2 * len + 1);
  871.     /* micha1104, #211 */
  872.     if (BCDNumber[0] == 0x91)
  873.     {
  874.         outString[j++] = '+';
  875.     }
  877.     /* micha1104, #211 */
  878.     for (i = 1; i < len; i++)
  879.     {
  880.         outString[j++] = ConvertDigitToChar((U8) (BCDNumber[i] & 0x0F));
  881.         outString[j] = ConvertDigitToChar((U8) ((BCDNumber[i] >> 4) & 0x0F));
  882.         if (outString[j++] == 0)
  883.         {
  884.             if (outLen)
  885.             {
  886.                 *outLen = j;
  887.             }
  888.             return outString;
  889.         }
  890.     }
  891.     outString[j++] = 0;
  892.     if (outLen)
  893.     {
  894.         *outLen = j;
  895.     }
  896.     return outString;
  897. }
  900. /*****************************************************************************
  901.  * FUNCTION
  902.  *  ConvertDigitToChar
  903.  * DESCRIPTION
  904.  *  Converts  BCD Digit to Char
  905.  * PARAMETERS
  906.  *  digit       [IN]        BCD Digit
  907.  * RETURNS
  908.  *  Character format of BCD Digit
  909.  *****************************************************************************/
  910. U8 ConvertDigitToChar(U8 digit)
  911. {
  912.     /*----------------------------------------------------------------*/
  913.     /* Local Variables                                                */
  914.     /*----------------------------------------------------------------*/
  916.     /*----------------------------------------------------------------*/
  917.     /* Code Body                                                      */
  918.     /*----------------------------------------------------------------*/
  919.     /* diamond, 2006/02/13 Re-assign the value of BCD encoding numbers */
  920.     if (digit < 10)
  921.     {
  922.         return 48 + digit;
  923.     }
  924.     else if (digit == 10)
  925.     {
  926.         return 42;  /* '*' */
  927.     }
  928.     else if (digit == 11)
  929.     {
  930.         return 35;      /* '#' */
  931.     }
  932.     else if (digit == 12)
  933.     {
  934.         return 0x70;    /* 'p' */
  935.     }
  936.     else if (digit == 13)
  937.     {
  938.         return 0x77;    /* 'w' */
  939.     }
  940.     else if (digit == 14)
  941.     {
  942.         return 43;  /* '+' */
  943.     }
  944.     else
  945.     {
  946.         return 0;
  947.     }
  948. }
  951. /*****************************************************************************
  952.  * FUNCTION
  953.  *  SwapEndian
  954.  * DESCRIPTION
  955.  *  Converts  Little Endian to Big Endian & vice versa
  956.  * PARAMETERS
  957.  *  Addr        [IN]        Pointer to data to be swapped
  958.  *  Nb          [IN]        No. of bytes to be swapped
  959.  * RETURNS
  960.  *  Pointer to Swapped Digits(?)
  961.  *****************************************************************************/
  962. void *SwapEndian(void *Addr, const int Nb)
  963. {
  964.     /*----------------------------------------------------------------*/
  965.     /* Local Variables                                                */
  966.     /*----------------------------------------------------------------*/
  967.     /* micha1014 begin */
  968.     static char Swapped[16];
  969.     static U32 Result_align[4];
  970.     int i;
  972.     /*----------------------------------------------------------------*/
  973.     /* Code Body                                                      */
  974.     /*----------------------------------------------------------------*/
  975.     switch (Nb)
  976.     {
  977.         case 2:
  978.             Swapped[0] = *((char*)Addr + 1);
  979.             Swapped[1] = *((char*)Addr);
  980.             break;
  981.         case 4:
  982.             Swapped[0] = *((char*)Addr + 3);
  983.             Swapped[1] = *((char*)Addr + 2);
  984.             Swapped[2] = *((char*)Addr + 1);
  985.             Swapped[3] = *((char*)Addr);
  986.             break;
  987.         case 8:
  988.             Swapped[0] = *((char*)Addr + 7);
  989.             Swapped[1] = *((char*)Addr + 6);
  990.             Swapped[2] = *((char*)Addr + 5);
  991.             Swapped[3] = *((char*)Addr + 4);
  992.             Swapped[4] = *((char*)Addr + 3);
  993.             Swapped[5] = *((char*)Addr + 2);
  994.             Swapped[6] = *((char*)Addr + 1);
  995.             Swapped[7] = *((char*)Addr);
  996.             break;
  997.         case 16:
  998.             Swapped[0] = *((char*)Addr + 15);
  999.             Swapped[1] = *((char*)Addr + 14);
  1000.             Swapped[2] = *((char*)Addr + 13);
  1001.             Swapped[3] = *((char*)Addr + 12);
  1002.             Swapped[4] = *((char*)Addr + 11);
  1003.             Swapped[5] = *((char*)Addr + 10);
  1004.             Swapped[6] = *((char*)Addr + 9);
  1005.             Swapped[7] = *((char*)Addr + 8);
  1006.             Swapped[8] = *((char*)Addr + 7);
  1007.             Swapped[9] = *((char*)Addr + 6);
  1008.             Swapped[10] = *((char*)Addr + 5);
  1009.             Swapped[11] = *((char*)Addr + 4);
  1010.             Swapped[12] = *((char*)Addr + 3);
  1011.             Swapped[13] = *((char*)Addr + 2);
  1012.             Swapped[14] = *((char*)Addr + 1);
  1013.             Swapped[15] = *((char*)Addr);
  1014.             break;
  1015.     }
  1017.     for (i = 0; i < 16; i++)
  1018.     {
  1019.         *((char*)Result_align + i) = Swapped[i];
  1020.     }
  1022.     return (void*)Result_align;
  1023.     /* micha1014 end */
  1024. }
  1026. /* flag=1: Handle extended characters. flag=0: Ignore extended characters  */
  1027. /* UCS2_count=0 for Default DCS, non zero for UCS2 DCS                  */
  1030. /*****************************************************************************
  1031.  * FUNCTION
  1032.  *  InputboxConvertGSMToDeviceEncoding
  1033.  * DESCRIPTION
  1034.  *  
  1035.  * PARAMETERS
  1036.  *  inBuffer            [?]         
  1037.  *  outBuffer           [?]         
  1038.  *  inBufferLength      [IN]        
  1039.  *  outBufferSize       [IN]        
  1040.  *  UCS2_count          [IN]        
  1041.  *  GSM_ext_count       [IN]        
  1042.  *  flag                [IN]        
  1043.  * RETURNS
  1044.  *  
  1045.  *****************************************************************************/
  1046. S32 InputboxConvertGSMToDeviceEncoding(
  1047.         U8 *inBuffer,
  1048.         U8 *outBuffer,
  1049.         U8 inBufferLength,
  1050.         S32 outBufferSize,
  1051.         S32 UCS2_count,
  1052.         S32 GSM_ext_count,
  1053.         U8 flag)
  1054. {
  1055.     /*----------------------------------------------------------------*/
  1056.     /* Local Variables                                                */
  1057.     /*----------------------------------------------------------------*/
  1058.     U8 done = 0;
  1059.     UI_buffer_type p1 = (UI_buffer_type) inBuffer;
  1060.     UI_buffer_type p2 = (UI_buffer_type) outBuffer;
  1061.     UI_character_type c, cc;
  1062.     S32 out_count = 0;
  1063.     U8 in_count = 0;
  1065.     /*----------------------------------------------------------------*/
  1066.     /* Code Body                                                      */
  1067.     /*----------------------------------------------------------------*/
  1068.     if (flag)
  1069.     {
  1070.         if (UCS2_count == 0)    /* ASCII */
  1071.         {
  1072.             while (!done)
  1073.             {
  1074.                 UI_GET_NEXT_BYTE(p1, c);
  1075.                 in_count++;
  1076.                 if (UI_STRING_END_OF_STRING_CHARACTER(c) && (in_count > inBufferLength))        /* Also check in_conut to make sure all chracter converted */
  1077.                 {
  1078.                     done = 1;
  1079.                     UI_STRING_INSERT_CHARACTER(p2, c);  /* Insert NULL terminator */
  1080.                     out_count += ENCODING_LENGTH;
  1081.                 }
  1082.                 else if (UI_TEST_ESC_CHARACTER(c))
  1083.                 {
  1084.                     cc = c;
  1085.                     UI_GET_NEXT_BYTE(p1, c);
  1086.                     in_count++;
  1087.                     c = DefaultToExtendedAsciiArray[c];
  1088.                     if (UI_TEST_GSM_EXTENDED(c))
  1089.                     {
  1090.                         UI_STRING_INSERT_CHARACTER(p2, c);
  1091.                         out_count += ENCODING_LENGTH;
  1092.                     }
  1093.                     else
  1094.                     {
  1095.                         UI_GET_PREVIOUS_BYTE(p1, c);
  1096.                         in_count--;
  1097.                         c = DefaultToAsciiArray[cc];
  1098.                         UI_STRING_INSERT_CHARACTER(p2, c);
  1099.                         out_count += ENCODING_LENGTH;
  1100.                     }
  1101.                 }
  1102.                 else
  1103.                 {
  1104.                     c = DefaultToAsciiArray[c];
  1105.                     UI_STRING_INSERT_CHARACTER(p2, c);
  1106.                     out_count += ENCODING_LENGTH;
  1107.                 }
  1108.                 if (out_count >= (outBufferSize - 2))   /* To ensure null terminator at the end when exceeds buffer. */
  1109.                 {
  1110.                     done = 1;
  1111.                     UI_STRING_INSERT_CHARACTER(p2, 0);
  1112.                     out_count += ENCODING_LENGTH;
  1113.                 }
  1114.             }
  1115.         }
  1116.         else    /* MMI_PHB_UCS2 */
  1117.     #if defined(__PHB_0x81_SUPPORT__)       /* Support maximum length of 0x81 and 0x82 UCS2 */
  1118.         if (UCS2_count == 0x08)
  1119.     #endif 
  1120.         {
  1121.             while (!done)
  1122.             {
  1123.                 UI_STRING_GET_NEXT_CHARACTER(p1, c);
  1124.                 UI_SWAP_U16_BYTES(c);
  1125.                 if (UI_STRING_END_OF_STRING_CHARACTER(c))
  1126.                 {
  1127.                     done = 1;
  1128.                 }
  1129.                 //if(c==_EURO_CHARACTER_UCS2) 
  1130.                 //  c=_EURO_CHARACTER;
  1131.                 UI_STRING_INSERT_CHARACTER(p2, c);  /* Append character here, including null terminator */
  1132.                 out_count += ENCODING_LENGTH;
  1134.                 if (out_count >= (outBufferSize - 2))   /* To ensure null terminator at the end when exceeds buffer. */
  1135.                 {
  1136.                     done = 1;
  1137.                     UI_STRING_INSERT_CHARACTER(p2, 0);
  1138.                     out_count += ENCODING_LENGTH;
  1139.                 }
  1140.             }
  1141.         }
  1142.     #if defined(__PHB_0x81_SUPPORT__)       /* Support maximum length of 0x81 and 0x82 UCS2 */
  1143.         else if (UCS2_count == 0x09)    /* MMI_PHB_UCS2_81 */
  1144.         {
  1145.             U16 base_ptr;
  1146.             U8 i, length;
  1148.             UI_GET_NEXT_BYTE(p1, c);
  1149.             UI_GET_NEXT_BYTE(p1, c);
  1150.             length = (U8) c;
  1151.             base_ptr = (*p1) << 7;
  1152.             UI_GET_NEXT_BYTE(p1, c);
  1154.             for (i = 0; i < length; i++)
  1155.             {
  1156.                 if (out_count >= (outBufferSize - 2))
  1157.                 {
  1158.                     break;
  1159.                 }
  1161.                 UI_GET_NEXT_BYTE(p1, c);
  1163.                 if (c < 0x80)   /* Default GSM character */
  1164.                 {
  1165.                     *(p2)++ = (U8) c;
  1166.                     *(p2)++ = 0x0;
  1167.                 }
  1168.                 else    /* UCS2 character */
  1169.                 {
  1170.                     c &= 0x7F;
  1171.                     c += base_ptr;
  1173.                     *(p2)++ = c & 0xFF;
  1174.                     *(p2)++ = c >> 8 & 0xFF;
  1175.                 }
  1176.             }
  1178.             UI_STRING_INSERT_CHARACTER(p2, 0);  /* Add null terminator at the end */
  1179.             out_count += ENCODING_LENGTH;
  1180.         }
  1181.         else if (UCS2_count == 0x10)    /* MMI_PHB_UCS2_82 */
  1182.         {
  1183.             U16 base_ptr;
  1184.             U8 i, length;
  1186.             UI_GET_NEXT_BYTE(p1, c);
  1187.             UI_GET_NEXT_BYTE(p1, c);
  1188.             length = (U8) c;
  1189.             base_ptr = (*p1) << 8;
  1190.             UI_GET_NEXT_BYTE(p1, c);
  1191.             base_ptr |= (*p1);
  1192.             UI_GET_NEXT_BYTE(p1, c);
  1194.             for (i = 0; i < length; i++)
  1195.             {
  1196.                 if (out_count >= (outBufferSize - 2))
  1197.                 {
  1198.                     break;
  1199.                 }
  1201.                 UI_GET_NEXT_BYTE(p1, c);
  1203.                 if (c < 0x80)   /* Default GSM character */
  1204.                 {
  1205.                     *(p2)++ = (U8) c;
  1206.                     *(p2)++ = 0x0;
  1207.                 }
  1208.                 else    /* UCS2 character */
  1209.                 {
  1210.                     c &= 0x7F;
  1211.                     c += base_ptr;
  1213.                     *(p2)++ = c & 0xFF;
  1214.                     *(p2)++ = c >> 8 & 0xFF;
  1215.                 }
  1217.                 out_count += ENCODING_LENGTH;
  1218.             }
  1220.             UI_STRING_INSERT_CHARACTER(p2, 0);  /* Add null terminator at the end */
  1221.             out_count += ENCODING_LENGTH;
  1222.         }
  1223.     #endif /* defined(__PHB_0x81_SUPPORT__) */ 
  1224.     }
  1225.     return out_count;
  1226. }
  1228. /* flag=1: Handle extended characters. flag=0: Ignore extended characters  */
  1229. /* UCS2_count=0 for Default DCS, non zero for UCS2 DCS                  */
  1232. /*****************************************************************************
  1233.  * FUNCTION
  1234.  *  InputboxConvertDeviceEncodingToGSM
  1235.  * DESCRIPTION
  1236.  *  
  1237.  * PARAMETERS
  1238.  *  inBuffer            [?]         
  1239.  *  outBuffer           [?]         
  1240.  *  outBufferSize       [IN]        
  1241.  *  UCS2_count          [IN]        
  1242.  *  GSM_ext_count       [IN]        
  1243.  *  flag                [IN]        
  1244.  * RETURNS
  1245.  *  
  1246.  *****************************************************************************/
  1247. S32 InputboxConvertDeviceEncodingToGSM(
  1248.         U8 *inBuffer,
  1249.         U8 *outBuffer,
  1250.         S32 outBufferSize,
  1251.         S32 UCS2_count,
  1252.         S32 GSM_ext_count,
  1253.         U8 flag)
  1254. {
  1255.     /*----------------------------------------------------------------*/
  1256.     /* Local Variables                                                */
  1257.     /*----------------------------------------------------------------*/
  1258.     U8 done = 0;
  1259.     UI_buffer_type p1 = (UI_buffer_type) inBuffer;
  1260.     UI_buffer_type p2 = (UI_buffer_type) outBuffer;
  1261.     UI_character_type c;
  1262.     S32 out_count = 0;
  1264.     /*----------------------------------------------------------------*/
  1265.     /* Code Body                                                      */
  1266.     /*----------------------------------------------------------------*/
  1267.     if (flag)
  1268.     {
  1269.         if (UCS2_count == 0)
  1270.         {
  1271.             while (!done)
  1272.             {
  1273.                 UI_STRING_GET_NEXT_CHARACTER(p1, c);
  1274.                 if (UI_STRING_END_OF_STRING_CHARACTER(c))
  1275.                 {
  1276.                     done = 1;
  1277.                     UI_INSERT_BYTE(p2, c);
  1278.                     out_count += 1;
  1279.                 }
  1280.                 else if (UI_TEST_GSM_EXTENDED(c))
  1281.                 {
  1282.                     UI_INSERT_BYTE(p2, _ESCAPE_CHARACTER);
  1283.                     c = ExtendedAsciiToDefaultArray[c];
  1284.                     UI_INSERT_BYTE(p2, c);
  1285.                     out_count += 2; /* MTK 2003-12-29 */
  1286.                 }
  1287.                 else
  1288.                 {
  1289.                     c = AsciiToDefaultArray[c];
  1290.                     UI_INSERT_BYTE(p2, c);
  1291.                     out_count += 1;
  1292.                 }
  1293.                 if (out_count >= outBufferSize)
  1294.                 {
  1295.                     done = 1;
  1296.                 }
  1297.             }
  1298.         }
  1299.         else
  1300.         {
  1301.             while (!done)
  1302.             {
  1303.                 UI_STRING_GET_NEXT_CHARACTER(p1, c);
  1304.                 if (UI_STRING_END_OF_STRING_CHARACTER(c))
  1305.                 {
  1306.                     done = 1;
  1307.                 }
  1308.                 /* if(c==_EURO_CHARACTER) c=_EURO_CHARACTER_UCS2; */
  1309.                 UI_SWAP_U16_BYTES(c);
  1310.                 UI_STRING_INSERT_CHARACTER(p2, c);
  1311.                 out_count += ENCODING_LENGTH;
  1312.                 if (out_count >= outBufferSize)
  1313.                 {
  1314.                     done = 1;
  1315.                 }
  1316.             }
  1317.         }
  1318.     }
  1319.     else
  1320.     {
  1321.         if (UCS2_count == 0)
  1322.         {
  1323.             while (!done)
  1324.             {
  1325.                 UI_STRING_GET_NEXT_CHARACTER(p1, c);
  1326.                 if (UI_STRING_END_OF_STRING_CHARACTER(c))
  1327.                 {
  1328.                     done = 1;
  1329.                     UI_INSERT_BYTE(p2, c);
  1330.                 }
  1331.                 else
  1332.                 {
  1333.                     c = AsciiToDefaultArray[c];
  1334.                     UI_INSERT_BYTE(p2, c);
  1335.                 }
  1336.                 out_count += 1;
  1337.                 if (out_count >= outBufferSize)
  1338.                 {
  1339.                     done = 1;
  1340.                 }
  1341.             }
  1342.         }
  1343.         else
  1344.         {
  1345.             while (!done)
  1346.             {
  1347.                 UI_STRING_GET_NEXT_CHARACTER(p1, c);
  1348.                 if (UI_STRING_END_OF_STRING_CHARACTER(c))
  1349.                 {
  1350.                     done = 1;
  1351.                 }
  1352.                 /* if(c==_EURO_CHARACTER) c=_EURO_CHARACTER_UCS2; */
  1353.                 UI_SWAP_U16_BYTES(c);
  1354.                 UI_STRING_INSERT_CHARACTER(p2, c);
  1355.                 out_count += ENCODING_LENGTH;
  1356.                 if (out_count >= outBufferSize)
  1357.                 {
  1358.                     done = 1;
  1359.                 }
  1360.             }
  1361.         }
  1362.     }
  1363.     return (out_count);
  1364. }