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

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

MTK

开发平台：

C/C++

UCS2.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.  *
  38.  * Filename:
  39.  * ---------
  40.  *   UCS2.c
  41.  *
  42.  * Project:
  43.  * --------
  44.  *   MAUI
  45.  *
  46.  * Description:
  47.  * ------------
  48.  *   UCS2 utility
  49.  *
  50.  * Author:
  51.  * -------
  52.  * -------
  53.  *  
  54.  *============================================================================
  55.  *             HISTORY
  56.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  57.  *------------------------------------------------------------------------------
  58.  * removed!
  59.  *
  60.  * removed!
  61.  * removed!
  62.  * removed!
  63.  *
  64.  * removed!
  65.  * removed!
  66.  * removed!
  67.  *
  68.  * removed!
  69.  * removed!
  70.  * removed!
  71.  *
  72.  * removed!
  73.  * removed!
  74.  * removed!
  75.  *
  76.  * removed!
  77.  * removed!
  78.  * removed!
  79.  *
  80.  * removed!
  81.  * removed!
  82.  * removed!
  83.  *
  84.  *------------------------------------------------------------------------------
  85.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  86.  *============================================================================
  87.  ****************************************************************************/
  89. /**
  90.  * Copyright Notice
  91.  * ?2002 - 2003, Pixtel Communications, Inc., 1489 43rd Ave. W.,
  92.  * Vancouver, B.C. V6M 4K8 Canada. All Rights Reserved.
  93.  *  (It is illegal to remove this copyright notice from this software or any
  94.  *  portion of it)
  95.  */
  97. /**********************************************************************************
  98.    Filename:      UCS2.c
  99.    Author:        Manish
  100.    Date Created:  Feb 5-2003
  101.    Contains:      
  102. **********************************************************************************/
  104. #include "PixtelDataTypes.h"
  105. #include "Ucs2dcl.h"
  106. #include "Ucs2prot.h"
  107. #include "Unicodexdcl.h"
  108. #include "string.h"
  109. #include "DebugInitDef.h"
  110. #ifndef MMI_ON_WIN32
  111. #include "app_str.h"
  112. #endif
  114. /*****************************************************************************
  115.  * FUNCTION
  116.  *  UnicodeToUCS2Encoding
  117.  * DESCRIPTION
  118.  *  convert unicode to UCS2 encoding
  119.  * PARAMETERS
  120.  *  unicode         [IN]        Value to be encoded
  121.  *  charLength      [OUT]         
  122.  *  arrOut          [OUT]         
  123.  * RETURNS
  124.  *  U8 -> Status
  125.  *****************************************************************************/
  126. U8 UnicodeToUCS2Encoding(U16 unicode, U8 *charLength, U8 *arrOut)
  127. {
  128. #ifndef MMI_ON_WIN32
  129.     /*----------------------------------------------------------------*/
  130.     /* Local Variables                                                */
  131.     /*----------------------------------------------------------------*/
  133.     /*----------------------------------------------------------------*/
  134.     /* Code Body                                                      */
  135.     /*----------------------------------------------------------------*/
  136.     /* On the Target */
  137.     return (U8)app_unicode_to_ucs2encoding(
  138.                 (kal_uint16)unicode, 
  139.                 (kal_uint8*)charLength,
  140.                 (kal_uint8*)arrOut);
  142. #else
  143.     /*----------------------------------------------------------------*/
  144.     /* Local Variables                                                */
  145.     /*----------------------------------------------------------------*/
  147.     U8 status = ST_SUCCESS;
  148.     U8 index = 0;
  150.     /*----------------------------------------------------------------*/
  151.     /* Code Body                                                      */
  152.     /*----------------------------------------------------------------*/
  153.     if (arrOut != 0)
  154.     {
  156.         if (unicode < 256)
  157.         {
  158.             arrOut[index++] = *((U8*) (&unicode));
  159.             arrOut[index] = 0;
  161.         }
  162.         else
  163.         {
  164.             arrOut[index++] = *((U8*) (&unicode));
  165.             arrOut[index] = *(((U8*) (&unicode)) + 1);
  167.         }
  168.         *charLength = 2;
  169.     }
  170.     else
  171.     {
  173.         status = ST_FAILURE;
  174.     }
  176.     return status;
  177. #endif
  178. }
  181. /*****************************************************************************
  182.  * FUNCTION
  183.  *  UCS2EncodingToUnicode
  184.  * DESCRIPTION
  185.  *  convert UCS2 encoded scheme to unicode
  186.  * PARAMETERS
  187.  *  pUnicode        [IN]        array containing  UCS2 encoded characters
  188.  *  arr             [IN]        unicode equivalent
  189.  * RETURNS
  190.  *  U8 -> Status
  191.  *****************************************************************************/
  192. U8 UCS2EncodingToUnicode(PU16 pUnicode, PU8 arr)
  193. {
  194. #ifndef MMI_ON_WIN32
  195.     /*----------------------------------------------------------------*/
  196.     /* Local Variables                                                */
  197.     /*----------------------------------------------------------------*/
  199.     /*----------------------------------------------------------------*/
  200.     /* Code Body                                                      */
  201.     /*----------------------------------------------------------------*/
  202.     /* On the Target */
  203.     return (U8)app_ucs2encoding_to_unicode((kal_uint16 *)pUnicode, (kal_uint8*)arr);
  205. #else
  206.     /*----------------------------------------------------------------*/
  207.     /* Local Variables                                                */
  208.     /*----------------------------------------------------------------*/
  210.     U8 index = 0;
  211.     U8 status = ST_SUCCESS;
  213.     /*----------------------------------------------------------------*/
  214.     /* Code Body                                                      */
  215.     /*----------------------------------------------------------------*/
  216.     if ((arr != NULL) && (pUnicode != NULL))
  217.     {
  219.         *((U8*) (pUnicode)) = arr[index++];
  220.         *(((U8*) (pUnicode)) + 1) = arr[index];
  221.     }
  222.     else
  223.     {
  225.         status = ST_FAILURE;
  226.     }
  228.     return status;
  229. #endif
  230. }
  233. /*****************************************************************************
  234.  * FUNCTION
  235.  *  UCS2Strlen
  236.  * DESCRIPTION
  237.  *  Gives the length of UCS2 encoded string
  238.  * PARAMETERS
  239.  *  arrOut      [IN]        array containing  UCS2 encoded characters
  240.  * RETURNS
  241.  *  U16 -> Status
  242.  *****************************************************************************/
  243. S32 UCS2Strlen(const S8 *arrOut)
  244. {
  245. #ifndef MMI_ON_WIN32
  246.     /*----------------------------------------------------------------*/
  247.     /* Local Variables                                                */
  248.     /*----------------------------------------------------------------*/
  250.     /*----------------------------------------------------------------*/
  251.     /* Code Body                                                      */
  252.     /*----------------------------------------------------------------*/
  253.     /* On the Target */
  254.     return (S32)app_ucs2_strlen((const kal_int8 *)arrOut);
  256. #else
  257.     /*----------------------------------------------------------------*/
  258.     /* Local Variables                                                */
  259.     /*----------------------------------------------------------------*/
  261.     S32 nCount = 0;
  262.     S32 nLength = 0;
  264.     /*----------------------------------------------------------------*/
  265.     /* Code Body                                                      */
  266.     /*----------------------------------------------------------------*/
  267.     /* Check for NULL character only at the odd no. of bytes 
  268.        assuming forst byte start from zero */
  269.     if (arrOut)
  270.     {
  271.         while (arrOut[nCount] != 0 || arrOut[nCount + 1] != 0)
  272.         {
  273.             ++nLength;
  274.             nCount += 2;
  275.         }
  276.     }
  277.     return nLength; /* One is added to count 0th byte */
  278. #endif
  279. }
  282. /*****************************************************************************
  283.  * FUNCTION
  284.  *  UCS2Strcpy
  285.  * DESCRIPTION
  286.  *  copies the one UCS2 encoded string to other
  287.  * PARAMETERS
  288.  *  strDestination      [OUT]       StrDest-> Destination array
  289.  *  strSource           [IN]        
  290.  * RETURNS
  291.  *  PS8 -> pointer to destination string or NULL
  292.  *****************************************************************************/
  293. S8 *UCS2Strcpy(S8 *strDestination, const S8 *strSource)
  294. {
  295. #ifndef MMI_ON_WIN32
  296.     /*----------------------------------------------------------------*/
  297.     /* Local Variables                                                */
  298.     /*----------------------------------------------------------------*/
  300.     /*----------------------------------------------------------------*/
  301.     /* Code Body                                                      */
  302.     /*----------------------------------------------------------------*/
  303.     /* On the Target */
  304.     return (S8*)app_ucs2_strcpy((kal_int8*)strDestination, (const kal_int8*)strSource);
  306. #else
  307.     /*----------------------------------------------------------------*/
  308.     /* Local Variables                                                */
  309.     /*----------------------------------------------------------------*/
  311.     U16 count = 1;
  312.     S8 *temp = strDestination;
  314.     /*----------------------------------------------------------------*/
  315.     /* Code Body                                                      */
  316.     /*----------------------------------------------------------------*/
  317.     if (strSource == NULL)
  318.     {
  319.         if (strDestination)
  320.         {
  321.             *(strDestination + count - 1) = '';
  322.             *(strDestination + count) = '';
  323.         }
  324.         return temp;
  326.     }
  328.     if (strDestination == NULL || strSource == NULL)
  329.     {
  330.         return NULL;
  331.     }
  332.     while (!((*(strSource + count) == 0) && (*(strSource + count - 1) == 0)))
  333.     {
  335.         *(strDestination + count - 1) = *(strSource + count - 1);
  336.         *(strDestination + count) = *(strSource + count);
  337.         count += 2;
  338.     }
  340.     *(strDestination + count - 1) = '';
  341.     *(strDestination + count) = '';
  343.     return temp;
  344. #endif
  345. }
  348. /*****************************************************************************
  349.  * FUNCTION
  350.  *  UCS2Strcmp
  351.  * DESCRIPTION
  352.  *  compares two strings
  353.  * PARAMETERS
  354.  *  string1     [IN]        > first String
  355.  *  string2     [OUT]       > Second String
  356.  * RETURNS
  357.  *  
  358.  *****************************************************************************/
  359. S32 UCS2Strcmp(const S8 *string1, const S8 *string2)
  360. {
  361. #ifndef MMI_ON_WIN32
  362.     /*----------------------------------------------------------------*/
  363.     /* Local Variables                                                */
  364.     /*----------------------------------------------------------------*/
  366.     /*----------------------------------------------------------------*/
  367.     /* Code Body                                                      */
  368.     /*----------------------------------------------------------------*/
  369.     /* On the Target */
  370.     return (S32)app_ucs2_strcmp((const kal_int8*)string1, (const kal_int8*)string2);
  372. #else
  373.     /*----------------------------------------------------------------*/
  374.     /* Local Variables                                                */
  375.     /*----------------------------------------------------------------*/
  377.     /*----------------------------------------------------------------*/
  378.     /* Code Body                                                      */
  379.     /*----------------------------------------------------------------*/
  380.     while ((*string1 == *string2) && (*(string1 + 1) == *(string2 + 1)))
  381.     {
  383.         if ((*string1 == 0) && (*(string1 + 1) == 0))
  384.         {
  385.             return 0;
  386.         }
  388.         string1 += 2;
  389.         string2 += 2;
  391.     }   /* End of while */
  393.     /* The return value indicates the lexicographic relation of string1 to string2 */
  394.     /* ie  < 0 , > 0 and 0 */
  395.     if (*string1 == *string2 && *(string1 + 1) != *(string2 + 1))
  396.     {
  397.         return (*(string1 + 1) - *(string2 + 1));
  398.     }
  399.     else
  400.     {
  401.         return (*string1 - *string2);
  403.     }
  404. #endif
  405. }
  408. /*****************************************************************************
  409.  * FUNCTION
  410.  *  UCS2Strncmp
  411.  * DESCRIPTION
  412.  *  compares two strings
  413.  *  
  414.  *  In size pass no of characters not bytes
  415.  * PARAMETERS
  416.  *  string1     [IN]        > first String
  417.  *  string2     [OUT]       > Second String
  418.  *  size        [IN]        
  419.  * RETURNS
  420.  *  
  421.  *****************************************************************************/
  422. /* MTK Added by Tim for solve a potential wrong answer when string1 and string2 are the same and less than "size" */
  423. S32 UCS2Strncmp(const S8 *string1, const S8 *string2, U32 size)
  424. {
  425. #ifndef MMI_ON_WIN32
  426.     /*----------------------------------------------------------------*/
  427.     /* Local Variables                                                */
  428.     /*----------------------------------------------------------------*/
  430.     /*----------------------------------------------------------------*/
  431.     /* Code Body                                                      */
  432.     /*----------------------------------------------------------------*/
  433.     /* On the Target */
  434.     return (S32)app_ucs2_strncmp(
  435.                     (const kal_int8*)string1,
  436.                     (const kal_int8*)string2,
  437.                     (kal_uint32)size);
  439. #else
  440.     /*----------------------------------------------------------------*/
  441.     /* Local Variables                                                */
  442.     /*----------------------------------------------------------------*/
  443.     U32 count = 0;
  444.     U16 nStr1;
  445.     U16 nStr2;
  447.     /*----------------------------------------------------------------*/
  448.     /* Code Body                                                      */
  449.     /*----------------------------------------------------------------*/
  450.     size = size << 1;   /* User is passing no of charcters not bytes */
  452.     while (count < size)
  453.     {
  454.         nStr1 = (string1[1] << 8) | string1[0];
  455.         nStr2 = (string2[1] << 8) | string2[0];
  456.         if (nStr1 == 0 || nStr2 == 0 || nStr1 != nStr2)
  457.         {
  458.             return nStr1 - nStr2;
  459.         }
  460.         string1 += 2;
  461.         string2 += 2;
  462.         count += 2;
  463.     }
  464.     return 0;
  465. #endif
  466. }
  469. /*****************************************************************************
  470.  * FUNCTION
  471.  *  UCS2Strncpy
  472.  * DESCRIPTION
  473.  *  copies the one UCS2 encoded string to other
  474.  *  
  475.  *  In size pass no of characters not bytes
  476.  * PARAMETERS
  477.  *  strDestination      [OUT]       StrDest-> Destination array
  478.  *  strSource           [IN]        
  479.  *  size                [IN]        
  480.  * RETURNS
  481.  *  PS8 -> pointer to destination string or NULL
  482.  *****************************************************************************/
  483. S8 *UCS2Strncpy(S8 *strDestination, const S8 *strSource, U32 size)
  484. {
  485. #ifndef MMI_ON_WIN32
  486.     /*----------------------------------------------------------------*/
  487.     /* Local Variables                                                */
  488.     /*----------------------------------------------------------------*/
  490.     /*----------------------------------------------------------------*/
  491.     /* Code Body                                                      */
  492.     /*----------------------------------------------------------------*/
  493.     /* On the Target */
  494.     return (S8*)app_ucs2_strncpy(
  495.                     (kal_int8*)strDestination,
  496.                     (const kal_int8*)strSource,
  497.                     (kal_uint32)size);
  499. #else
  500.     /*----------------------------------------------------------------*/
  501.     /* Local Variables                                                */
  502.     /*----------------------------------------------------------------*/
  504.     U16 count = 1;
  505.     U32 count1 = 0;
  506.     S8 *temp = strDestination;
  508.     /*----------------------------------------------------------------*/
  509.     /* Code Body                                                      */
  510.     /*----------------------------------------------------------------*/
  511.     size = size * 2;
  513.     MMI_ASSERT(!(strDestination == NULL));
  515.     while (!((*(strSource + count) == 0) && (*(strSource + count - 1) == 0)) && (count1 < size))
  516.     {
  518.         *(strDestination + count - 1) = *(strSource + count - 1);
  519.         *(strDestination + count) = *(strSource + count);
  520.         count += 2;
  521.         count1 += 2;
  522.     }
  524.     *(strDestination + count - 1) = '';
  525.     *(strDestination + count) = '';
  527.     return temp;
  528. #endif
  529. }
  532. /*****************************************************************************
  533.  * FUNCTION
  534.  *  UCS2Strcat
  535.  * DESCRIPTION
  536.  *  
  537.  *  
  538.  *  User has to ensure that enough space is
  539.  *  available in destination
  540.  * PARAMETERS
  541.  *  strDestination      [OUT]         
  542.  *  strSource           [IN]        
  543.  * RETURNS
  544.  *  PS8
  545.  *****************************************************************************/
  546. S8 *UCS2Strcat(S8 *strDestination, const S8 *strSource)
  547. {
  548. #ifndef MMI_ON_WIN32
  549.     /*----------------------------------------------------------------*/
  550.     /* Local Variables                                                */
  551.     /*----------------------------------------------------------------*/
  553.     /*----------------------------------------------------------------*/
  554.     /* Code Body                                                      */
  555.     /*----------------------------------------------------------------*/
  556.     /* On the Target */
  557.     return (S8*)app_ucs2_strcat((kal_int8*)strDestination, (const kal_int8*)strSource);
  559. #else
  560.     /*----------------------------------------------------------------*/
  561.     /* Local Variables                                                */
  562.     /*----------------------------------------------------------------*/
  564.     S8 *dest = strDestination;
  566.     /*----------------------------------------------------------------*/
  567.     /* Code Body                                                      */
  568.     /*----------------------------------------------------------------*/
  569.     dest = dest + UCS2Strlen(strDestination) * ENCODING_LENGTH;
  571.     UCS2Strcpy(dest, strSource);
  572.     return strDestination;
  573. #endif
  574. }
  577. /*****************************************************************************
  578.  * FUNCTION
  579.  *  UCS2Strncat
  580.  * DESCRIPTION
  581.  *  
  582.  *  
  583.  *  User has to ensure that enough space is
  584.  *  available in destination
  585.  * PARAMETERS
  586.  *  strDestination      [OUT]         
  587.  *  strSource           [IN]        
  588.  *  size                [IN]        
  589.  * RETURNS
  590.  *  PS8
  591.  *****************************************************************************/
  592. S8 *UCS2Strncat(S8 *strDestination, const S8 *strSource, U32 size)
  593. {
  594. #ifndef MMI_ON_WIN32
  595.     /*----------------------------------------------------------------*/
  596.     /* Local Variables                                                */
  597.     /*----------------------------------------------------------------*/
  599.     /*----------------------------------------------------------------*/
  600.     /* Code Body                                                      */
  601.     /*----------------------------------------------------------------*/
  602.     /* On the Target */
  603.     return (S8*)app_ucs2_strncat(
  604.                     (kal_int8*)strDestination, 
  605.                     (const kal_int8*)strSource,
  606.                     (kal_uint32)size);
  608. #else
  609.     /*----------------------------------------------------------------*/
  610.     /* Local Variables                                                */
  611.     /*----------------------------------------------------------------*/
  613.     S8 *dest = strDestination;
  615.     /*----------------------------------------------------------------*/
  616.     /* Code Body                                                      */
  617.     /*----------------------------------------------------------------*/
  618.     dest = dest + UCS2Strlen(strDestination) * ENCODING_LENGTH;
  620.     UCS2Strncpy(dest, strSource, size);
  621.     return strDestination;
  622. #endif
  623. }
  626. /*****************************************************************************
  627.  * FUNCTION
  628.  *  UCS2StrAppendChar
  629.  * DESCRIPTION
  630.  *  
  631.  *  
  632.  *  User has to ensure that enough space is
  633.  *  available in destination
  634.  * PARAMETERS
  635.  *  strDestination      [OUT]         
  636.  *  ch                  [IN]        
  637.  * RETURNS
  638.  *  PS8
  639.  *****************************************************************************/
  640. S8 *UCS2StrAppendChar(S8 *strDestination, U16 ch)
  641. {
  642. #ifndef MMI_ON_WIN32
  643.     /*----------------------------------------------------------------*/
  644.     /* Local Variables                                                */
  645.     /*----------------------------------------------------------------*/
  647.     /*----------------------------------------------------------------*/
  648.     /* Code Body                                                      */
  649.     /*----------------------------------------------------------------*/
  650.     /* On the Target */
  651.     return (S8*)app_ucs2str_appendchar((kal_int8*)strDestination, (kal_uint16) ch);
  653. #else
  654.     /*----------------------------------------------------------------*/
  655.     /* Local Variables                                                */
  656.     /*----------------------------------------------------------------*/
  657.     S8 *dest = strDestination;
  658.     U16 buffer[2];
  660.     /*----------------------------------------------------------------*/
  661.     /* Code Body                                                      */
  662.     /*----------------------------------------------------------------*/
  663.     dest = dest + UCS2Strlen(strDestination) * ENCODING_LENGTH;
  664.     buffer[0] = ch;
  665.     buffer[1] = 0;
  667.     UCS2Strcpy(dest, (const S8*)buffer);
  668.     return strDestination;
  669. #endif
  670. }
  673. /*****************************************************************************
  674.  * FUNCTION
  675.  *  UCS2StrNAppendChar
  676.  * DESCRIPTION
  677.  *  
  678.  *  
  679.  *  User has to ensure that enough space is
  680.  *  available in destination
  681.  * PARAMETERS
  682.  *  strDestination      [OUT]         
  683.  *  ch                  [IN]        
  684.  *  size                [IN]        
  685.  * RETURNS
  686.  *  PS8
  687.  *****************************************************************************/
  688. S8 *UCS2StrNAppendChar(S8 *strDestination, U16 ch, U32 size)
  689. {
  690. #ifndef MMI_ON_WIN32
  691.     /*----------------------------------------------------------------*/
  692.     /* Local Variables                                                */
  693.     /*----------------------------------------------------------------*/
  695.     /*----------------------------------------------------------------*/
  696.     /* Code Body                                                      */
  697.     /*----------------------------------------------------------------*/
  698.     /* On the Target */
  699.     return (S8*)app_ucs2str_n_appendchar(
  700.                     (kal_int8*)strDestination,
  701.                     (kal_uint16) ch,
  702.                     (kal_uint32)size);
  704. #else
  705.     /*----------------------------------------------------------------*/
  706.     /* Local Variables                                                */
  707.     /*----------------------------------------------------------------*/
  708.     S8 *dest = strDestination;
  709.     U16 buffer[2];
  711.     /*----------------------------------------------------------------*/
  712.     /* Code Body                                                      */
  713.     /*----------------------------------------------------------------*/
  714.     dest = dest + UCS2Strlen(strDestination) * ENCODING_LENGTH;
  715.     buffer[0] = ch;
  716.     buffer[1] = 0;
  718.     UCS2Strncpy(dest, (const S8*)buffer, size);
  719.     return strDestination;
  720. #endif
  721. }
  723. /*****************************************************************************
  724.  * FUNCTION
  725.  *  UCS2Strchr
  726.  * DESCRIPTION
  727.  *  find the next chr 'c'
  728.  * IMPACT
  729.  *  will not affect input strSrc, but return a pointer to point out the place.
  730.  * PARAMETERS
  731.  *  strSrc      [IN]        
  732.  *  c           [IN]        
  733.  * RETURNS
  734.  *  
  735.  *****************************************************************************/
  736. S8 *UCS2Strchr(const S8 *strSrc, U16 c)
  737. {
  738.     /*----------------------------------------------------------------*/
  739.     /* Local Variables                                                */
  740.     /*----------------------------------------------------------------*/
  741.     U16 *chr = (U16*) strSrc;
  743.     /*----------------------------------------------------------------*/
  744.     /* Code Body                                                      */
  745.     /*----------------------------------------------------------------*/
  746.     do
  747.     {
  748.         if (*chr == c)
  749.         {
  750.             return (S8*) chr;
  751.         }
  752.     } while (*(++chr));
  753.     return NULL;
  754. }
  756. /*****************************************************************************
  757.  * FUNCTION
  758.  *  UCS2StrTrimLeft
  759.  * DESCRIPTION
  760.  *  skip over the TrimChars
  761.  * PARAMETERS
  762.  *  strSrc          [IN]        
  763.  *  TrimChars       [IN]        
  764.  * RETURNS
  765.  *  
  766.  *****************************************************************************/
  767. S8 *UCS2StrTrimLeft(const S8 *strSrc, const S8 *TrimChars)
  768. {
  769.     /*----------------------------------------------------------------*/
  770.     /* Local Variables                                                */
  771.     /*----------------------------------------------------------------*/
  772.     U16 *chr = (U16*) strSrc;
  773.     S32 trim_length = UCS2Strlen(TrimChars);
  775.     /*----------------------------------------------------------------*/
  776.     /* Code Body                                                      */
  777.     /*----------------------------------------------------------------*/
  778.     while (*chr)
  779.     {
  780.         S32 i = 0;
  782.         for (; i < trim_length; i++)
  783.         {
  784.             if (*chr == ((U16*) TrimChars)[i])
  785.             {
  786.                 chr++;
  787.                 break;
  788.             }
  789.         }
  790.         if (i == trim_length)
  791.         {
  792.             return (S8*) chr;
  793.         }
  794.     }
  795.     return NULL;
  796. }
  799. /*****************************************************************************
  800.  * FUNCTION
  801.  *  UCS2StrGetStr
  802.  * DESCRIPTION
  803.  *  search for the break_chars and store how many chars have been read over to reach
  804.  *  the desired break_char in read_length
  805.  * PARAMETERS
  806.  *  strSrc          [IN]        
  807.  *  break_chars     [IN]        
  808.  *  read_length     [?]         
  809.  *  direction       [IN]        1: sesarch forward ; -1: search backward.
  810.  * RETURNS
  811.  *  1: found the break_chars ;  -1: searched over the whole strSrc and do not fing the break_chars
  812.  *****************************************************************************/
  813. S32 UCS2StrGetStr(const S8 *strSrc, const S8 *break_chars, S32 *read_length, S16 direction)
  814. {
  815.     /*----------------------------------------------------------------*/
  816.     /* Local Variables                                                */
  817.     /*----------------------------------------------------------------*/
  818.     U16 *src = (U16*) strSrc;
  819.     S32 x = 0;
  820.     S32 break_chars_length = UCS2Strlen(break_chars);
  822.     /*----------------------------------------------------------------*/
  823.     /* Code Body                                                      */
  824.     /*----------------------------------------------------------------*/
  825.     while (*src)
  826.     {
  827.         for (x = 0; x < break_chars_length; x++)
  828.         {
  829.             if (*src == ((U16*) break_chars)[x])
  830.             {
  831.                 if (direction > 0)
  832.                 {
  833.                     *read_length = src - (U16*) strSrc;
  834.                 }
  835.                 else
  836.                 {
  837.                     *read_length = (U16*) strSrc - src;
  838.                 }
  839.                 return 1;
  840.             }
  841.         }
  842.         src += direction;
  843.     }
  844.     return -1;
  846. }
  849. /*****************************************************************************
  850.  * FUNCTION
  851.  *  UCS2StrGetNumInt
  852.  * DESCRIPTION
  853.  *  to parse over a int number, including positive and negative signs (+,-).
  854.  * PARAMETERS
  855.  *  strSrc          [IN]        
  856.  *  out_num         [?]         Is the parsed int number
  857.  *  read_length     [?]         
  858.  * RETURNS
  859.  *  1: parse successfully ; -1: parse number fail.
  860.  *****************************************************************************/
  861. S32 UCS2StrGetNumInt(const S8 *strSrc, S32 *out_num, S32 *read_length)
  862. {
  863.     /*----------------------------------------------------------------*/
  864.     /* Local Variables                                                */
  865.     /*----------------------------------------------------------------*/
  866. #define     GETNUM(wchar_p) (*wchar_p - L'0')
  868.     U16 *src = (U16*) strSrc;
  869.     BOOL is_negative = FALSE;
  870.     S32 num = 0;
  872.     /*----------------------------------------------------------------*/
  873.     /* Code Body                                                      */
  874.     /*----------------------------------------------------------------*/
  875.     if (*src == L'-')
  876.     {
  877.         is_negative = TRUE;
  878.         src++;
  879.     }
  880.     if (*src == L'+')
  881.     {
  882.         src++;
  883.     }
  884.     if (GETNUM(src) < 0 || GETNUM(src) > 9)
  885.     {
  886.         return -1;
  887.     }
  888.     while (*src)
  889.     {
  890.         if (GETNUM(src) < 0 || GETNUM(src) > 9)
  891.         {
  892.             break;
  893.         }
  894.         num = num * 10 + GETNUM(src);
  895.         src++;
  896.     }
  898.     *read_length = src - (U16*) strSrc;
  900.     if (is_negative)
  901.     {
  902.         *out_num = -num;
  903.     }
  904.     else
  905.     {
  906.         *out_num = num;
  907.     }
  908.     return 1;
  909. }
  912. /*****************************************************************************
  913.  * FUNCTION
  914.  *  AnsiiToUnicodeString
  915.  * DESCRIPTION
  916.  *  Converts Ansii encode string to unicode
  917.  *  
  918.  *  Caller has to ensure that pOutBuffer
  919.  *  should be as large
  920.  * PARAMETERS
  921.  *  pOutBuffer      [OUT]     
  922.  *  pInBuffer       [IN]     
  923.  * RETURNS
  924.  *  U16
  925.  *****************************************************************************/
  926. U16 AnsiiToUnicodeString(S8 *pOutBuffer, S8 *pInBuffer)
  927. {
  928. #ifndef MMI_ON_WIN32
  929.     /*----------------------------------------------------------------*/
  930.     /* Local Variables                                                */
  931.     /*----------------------------------------------------------------*/
  933.     /*----------------------------------------------------------------*/
  934.     /* Code Body                                                      */
  935.     /*----------------------------------------------------------------*/
  936.     /* On the Target */
  937.     return (U16)app_ansii_to_unicodestring((kal_int8*)pOutBuffer, (kal_int8*)pInBuffer);
  939. #else
  940.     /*----------------------------------------------------------------*/
  941.     /* Local Variables                                                */
  942.     /*----------------------------------------------------------------*/
  944.     S16 count = -1;
  945.     U8 charLen = 0;
  946.     U8 arrOut[2];
  948.     /*----------------------------------------------------------------*/
  949.     /* Code Body                                                      */
  950.     /*----------------------------------------------------------------*/
  951.     while (*pInBuffer != '')
  952.     {
  954.         UnicodeToUCS2Encoding((U16) * ((PU8) pInBuffer), &charLen, arrOut);
  956.         // #ifdef MMI_ON_WIN32
  957.         pOutBuffer[++count] = arrOut[0];
  958.         pOutBuffer[++count] = arrOut[1];
  959.         pInBuffer++;
  960.         // #endif
  962.     #ifdef __FOR_TESTING    /* MMI_ON_HARDWARE_P */
  963.         pOutBuffer[++count] = arrOut[1];    /* arrOut[0]; */
  964.         pOutBuffer[++count] = arrOut[0];    /* arrOut[1]; */
  965.         pInBuffer++;
  966.     #endif /* __FOR_TESTING */ 
  968.     }
  970.     pOutBuffer[++count] = '';
  971.     pOutBuffer[++count] = '';
  972.     return count + 1;
  973. #endif
  974. }
  977. /*****************************************************************************
  978.  * FUNCTION
  979.  *  AnsiiNToUnicodeString
  980.  * DESCRIPTION
  981.  *  Converts N character Ansii encode string to unicode
  982.  *  
  983.  *  Caller has to ensure that pOutBuffer
  984.  *  should be as large
  985.  * PARAMETERS
  986.  *  pOutBuffer      [OUT]         
  987.  *  pInBuffer       [IN]         
  988.  *  len             [IN]        
  989.  * RETURNS
  990.  *  U16
  991.  *****************************************************************************/
  992. U16 AnsiiNToUnicodeString(S8 *pOutBuffer, S8 *pInBuffer, U32 len)
  993. {
  994. #ifndef MMI_ON_WIN32
  995.     /*----------------------------------------------------------------*/
  996.     /* Local Variables                                                */
  997.     /*----------------------------------------------------------------*/
  999.     /*----------------------------------------------------------------*/
  1000.     /* Code Body                                                      */
  1001.     /*----------------------------------------------------------------*/
  1002.     /* On the Target */
  1003.     return (U16)app_ansii_n_to_unicodestring(
  1004.                     (kal_int8*)pOutBuffer,
  1005.                     (kal_int8*)pInBuffer,
  1006.                     (kal_uint32)len);
  1008. #else
  1009.     /*----------------------------------------------------------------*/
  1010.     /* Local Variables                                                */
  1011.     /*----------------------------------------------------------------*/
  1013.     S16 count = -1;
  1014.     U8 charLen = 0;
  1015.     U8 arrOut[2];
  1017.     /*----------------------------------------------------------------*/
  1018.     /* Code Body                                                      */
  1019.     /*----------------------------------------------------------------*/
  1020.     while (len)
  1021.     {
  1023.         UnicodeToUCS2Encoding((U16) * ((PU8) pInBuffer), &charLen, arrOut);
  1025.         // #ifdef MMI_ON_WIN32
  1026.         pOutBuffer[++count] = arrOut[0];
  1027.         pOutBuffer[++count] = arrOut[1];
  1029.         if (*pInBuffer == '')
  1030.         {
  1031.             break;
  1032.         }
  1033.         else
  1034.         {
  1035.             pInBuffer++;
  1036.         }
  1037.         // #endif
  1039.     #ifdef __FOR_TESTING    /* MMI_ON_HARDWARE_P */
  1040.         pOutBuffer[++count] = arrOut[1];    /* arrOut[0]; */
  1041.         pOutBuffer[++count] = arrOut[0];    /* arrOut[1]; */
  1042.         pInBuffer++;
  1043.     #endif /* __FOR_TESTING */ 
  1045.         len--;
  1047.     }
  1049.     return count + 1;
  1050. #endif
  1051. }
  1054. /*****************************************************************************
  1055.  * FUNCTION
  1056.  *  UnicodeToAnsii
  1057.  * DESCRIPTION
  1058.  *  Converts Unicode encode string to Ascii
  1059.  *  
  1060.  *  Caller has to ensure that pOutBuffer
  1061.  *  should be  large enough
  1062.  * PARAMETERS
  1063.  *  pOutBuffer      [OUT]     
  1064.  *  pInBuffer       [IN]     
  1065.  * RETURNS
  1066.  *  U16
  1067.  *****************************************************************************/
  1068. U16 UnicodeToAnsii(S8 *pOutBuffer, S8 *pInBuffer)
  1069. {
  1070. #ifndef MMI_ON_WIN32
  1071.     /*----------------------------------------------------------------*/
  1072.     /* Local Variables                                                */
  1073.     /*----------------------------------------------------------------*/
  1075.     /*----------------------------------------------------------------*/
  1076.     /* Code Body                                                      */
  1077.     /*----------------------------------------------------------------*/
  1078.     /* On the Target */
  1079.     return (U16)app_unicode_to_ansii((kal_int8*)pOutBuffer,(kal_int8*)pInBuffer);
  1081. #else
  1082.     /*----------------------------------------------------------------*/
  1083.     /* Local Variables                                                */
  1084.     /*----------------------------------------------------------------*/
  1086.     U16 count = 0;
  1088.     /*----------------------------------------------------------------*/
  1089.     /* Code Body                                                      */
  1090.     /*----------------------------------------------------------------*/
  1091.     while (!((*pInBuffer == 0) && (*(pInBuffer + 1) == 0)))
  1092.     {
  1093.         *pOutBuffer = *(pInBuffer);
  1095.     #ifdef __FOR_TESTING    /* MMI_ON_HARDWARE_P */
  1096.         *pOutBuffer = *(pInBuffer + 1);
  1097.     #endif 
  1098.         pInBuffer += 2;
  1099.         pOutBuffer++;
  1100.         count++;
  1101.     }
  1103.     *pOutBuffer = 0;
  1104.     return count;
  1105. #endif
  1106. }
  1109. /*****************************************************************************
  1110.  * FUNCTION
  1111.  *  UnicodeNToAnsii
  1112.  * DESCRIPTION
  1113.  *  Converts N character Unicode encode string to Ascii
  1114.  *  
  1115.  *  Caller has to ensure that pOutBuffer
  1116.  *  should be  large enough
  1117.  * PARAMETERS
  1118.  *  pOutBuffer      [OUT]         
  1119.  *  pInBuffer       [IN]         
  1120.  *  len             [IN]        
  1121.  * RETURNS
  1122.  *  U16
  1123.  *****************************************************************************/
  1124. U16 UnicodeNToAnsii(S8 *pOutBuffer, S8 *pInBuffer, U32 len)
  1125. {
  1126. #ifndef MMI_ON_WIN32
  1127.     /*----------------------------------------------------------------*/
  1128.     /* Local Variables                                                */
  1129.     /*----------------------------------------------------------------*/
  1131.     /*----------------------------------------------------------------*/
  1132.     /* Code Body                                                      */
  1133.     /*----------------------------------------------------------------*/
  1134.     /* On the Target */
  1135.     return (U16)app_unicode_n_to_ansii(
  1136.                     (kal_int8*)pOutBuffer,
  1137.                     (kal_int8*)pInBuffer,
  1138.                     (kal_uint32)len);
  1140. #else
  1141.     /*----------------------------------------------------------------*/
  1142.     /* Local Variables                                                */
  1143.     /*----------------------------------------------------------------*/
  1145.     U16 count = 0;
  1147.     /*----------------------------------------------------------------*/
  1148.     /* Code Body                                                      */
  1149.     /*----------------------------------------------------------------*/
  1150.     while ((len) && (!((*pInBuffer == 0) && (*(pInBuffer + 1) == 0))))
  1151.     {
  1152.         *pOutBuffer = *(pInBuffer);
  1154.     #ifdef __FOR_TESTING    /* MMI_ON_HARDWARE_P */
  1155.         *pOutBuffer = *(pInBuffer + 1);
  1156.     #endif 
  1157.         pInBuffer += 2;
  1158.         pOutBuffer++;
  1159.         count++;
  1160.         len -= 2;
  1161.     }
  1163.     return count;
  1164. #endif
  1165. }