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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > MTK > 查看源码
ft_utils.cpp
资源名称：Maui_META_src_v5.0808.0.zip　[点击查看]
上传用户：gelin96
上传日期：2017-01-08
资源大小：20993k
文件大小：36k
源码类别：

MTK

开发平台：

C++ Builder

ft_utils.cpp：源码内容
  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.  *   ft_utils.cpp
  41.  *
  42.  * Project:
  43.  * --------
  44.  *   Maui META APP
  45.  *
  46.  * Description:
  47.  * ------------
  48.  *  Format transformation function source
  49.  *
  50.  * Author:
  51.  * -------
  52.  *  Andy Ueng (mtk00490)
  53.  *
  54.  *============================================================================
  55.  *             HISTORY
  56.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  57.  *------------------------------------------------------------------------------
  58.  * $Revision$
  59.  * $Modtime$
  60.  * $Log$
  61.  * 
  62.  *------------------------------------------------------------------------------
  63.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  64.  *============================================================================
  65.  ****************************************************************************/
  66. #include <vcl.h>
  67. #include <math.h>
  68. #include <stdio.h>
  70. #ifndef __VISATYPE_HEADER__
  71. #include "visatype.h"
  72. #endif
  74. #pragma hdrstop
  76. #include "man_error.h"
  78. #ifndef  _META_UTILS_H_
  79. #include "meta_utils.h"
  80. #endif
  82. #ifndef  _RF_COMMON_H_
  83. #include "rf_common.h"
  84. #endif
  86. #ifndef  _STR_UTILS_H_
  87. #include "str_utils.h"
  88. #endif
  90. //------------------------------------------------------------------------------
  91. AnsiString Double_To_AnsiString(double d)
  92. {
  93.     char str[1024];
  94.     sprintf(str, "%f", d);
  95.     AnsiString ansi_str(str);
  97.     return ansi_str;
  98. }
  100. //------------------------------------------------------------------------------
  101. bool  AnsiString_To_Short(AnsiString ansi_str, short &out_value, short range_min=0, short range_max=-1 )
  102. {
  103.    /* check if each char is valid */
  104.    {  int   i;
  105.       char  ch;
  106.       char  str[256];
  107.       int   str_len = ansi_str.Length();
  108.       if(str_len==0)  return(false);
  109.       strcpy( str, ansi_str.c_str() );
  111.       for( i=0; i<str_len; i++ )
  112.       {  ch = str[i];
  113.          if( ((ch>='0')&&(ch<='9')) || (ch=='+') || (ch=='-') || (ch==' ') )   continue;
  114.          break;
  115.       }
  116.       if( i!=str_len )
  117.          return(false);
  118.    }
  119.    /* convert string to integer */
  120.    double d_out_value = atof(ansi_str.c_str());
  121.    if( d_out_value >= pow(2.0, sizeof(short)*8-1) )  return false;
  123.    out_value = ansi_str.ToInt();
  125.    /* chack value range */
  126.    if(range_min<=range_max)
  127.    {  if( (out_value<range_min)||(out_value>range_max) )
  128.          return(false);
  129.    }
  130.    return( true );
  131. }
  133. //---------------------------------------------------------------------------
  134. bool  AnsiString_To_UnsignedShort(AnsiString ansi_str, unsigned short &out_value, unsigned short range_min, unsigned short range_max )
  135. {
  136.    /* check if each char is valid */
  137.    {  int   i;
  138.       char  ch;
  139.       char  str[256];
  140.       int   str_len = ansi_str.Length();
  141.       if(str_len==0)  return(false);
  142.       strcpy( str, ansi_str.c_str() );
  144.       for( i=0; i<str_len; i++ )
  145.       {  ch = str[i];
  146.          if( ((ch>='0')&&(ch<='9')) || (ch=='+') || (ch=='-') || (ch==' ') )   continue;
  147.          break;
  148.       }
  149.       if( i!=str_len )
  150.          return(false);
  151.    }
  152.    /* convert string to integer */
  153.    double d_out_value = atof(ansi_str.c_str());
  154.    if( d_out_value >= pow(2.0, sizeof(unsigned short)*8) )  return false;
  155.    out_value = ansi_str.ToInt();
  157.    /* chack value range */
  158.    if(range_min<=range_max)
  159.    {  if( (out_value<range_min)||(out_value>range_max) )
  160.          return(false);
  161.    }
  162.    return( true );
  163. }
  165. //---------------------------------------------------------------------------
  166. bool  AnsiString_To_Integer(AnsiString ansi_str, int &out_value, int range_min=0, int range_max=-1 )
  167. {
  168.    /* check if each char is valid */
  169.    {  int   i;
  170.       char  ch;
  171.       char  str[256];
  172.       int   str_len = ansi_str.Length();
  173.       if(str_len==0)  return(false);
  174.       strcpy( str, ansi_str.c_str() );
  176.       for( i=0; i<str_len; i++ )
  177.       {  ch = str[i];
  178.          if( ((ch>='0')&&(ch<='9')) || (ch=='+') || (ch=='-') || (ch==' ') )   continue;
  179.          break;
  180.       }
  181.       if( i!=str_len )
  182.          return(false);
  183.    }
  184.    /* convert string to integer */
  185.    double d_out_value = atof(ansi_str.c_str());
  186.    if( d_out_value >= pow(2.0, sizeof(int)*8-1) )  return false;
  188.    out_value = ansi_str.ToInt();
  190.    /* chack value range */
  191.    if(range_min<=range_max)
  192.    {  if( (out_value<range_min)||(out_value>range_max) )
  193.          return(false);
  194.    }
  195.    return( true );
  196. }
  198. //---------------------------------------------------------------------------
  199. bool  AnsiString_To_UnsignedInteger(AnsiString ansi_str, unsigned int &out_value, unsigned int range_min, unsigned int range_max )
  200. {
  201.    /* check if each char is valid */
  202.    {  int   i;
  203.       char  ch;
  204.       char  str[256];
  205.       int   str_len = ansi_str.Length();
  206.       if(str_len==0)  return(false);
  207.       strcpy( str, ansi_str.c_str() );
  209.       for( i=0; i<str_len; i++ )
  210.       {  ch = str[i];
  211.          if( ((ch>='0')&&(ch<='9')) || (ch=='+') || (ch=='-') || (ch==' ') )   continue;
  212.          break;
  213.       }
  214.       if( i!=str_len )
  215.          return(false);
  216.    }
  217.    /* convert string to integer */
  218.    double d_out_value = atof(ansi_str.c_str());
  219.    if( d_out_value >= pow(2.0, sizeof(unsigned int)*8-1) )  return false;
  220.    out_value = ansi_str.ToInt();
  222.    /* chack value range */
  223.    if(range_min<=range_max)
  224.    {  if( (out_value<range_min)||(out_value>range_max) )
  225.          return(false);
  226.    }
  227.    return( true );
  228. }
  230. //---------------------------------------------------------------------------
  231. bool  AnsiString_To_char(AnsiString ansi_str, char &out_value, int range_min=0, int range_max=-1 )
  232. {
  233.    /* check if each char is valid */
  234.    {  int   i;
  235.       char  ch;
  236.       char  str[256];
  237.       int   str_len = ansi_str.Length();
  238.       if(str_len==0 || str_len >5)  return(false); // 2^8 = 256
  239.       strcpy( str, ansi_str.c_str() );
  241.       for( i=0; i<str_len; i++ )
  242.       {  ch = str[i];
  243.          if( ((ch>='0')&&(ch<='9')) || (ch=='+') || (ch=='-') || (ch==' ') )   continue;
  244.          break;
  245.       }
  246.       if( i!=str_len )
  247.          return(false);
  248.    }
  249.    /* convert string to integer */
  250.    double d_out_value = atof(ansi_str.c_str());
  251.    if( d_out_value >= pow(2.0, sizeof(char)*8-1) )  return false;
  253.   int int_out_value = ansi_str.ToInt();
  255.    /* chack value range */
  256.    if(range_min<=range_max)
  257.    {  if( (int_out_value<range_min)||(int_out_value>range_max) )
  258.          return(false);
  259.    }
  260.    out_value = (char) int_out_value & 0xFF;
  261.    return( true );
  262. }
  265. //---------------------------------------------------------------------------
  266. bool  AnsiString_To_signedchar(AnsiString ansi_str, signed char &out_value, int range_min=0, int range_max=-1 )
  267. {
  268.    /* check if each char is valid */
  269.    {  int   i;
  270.       char  ch;
  271.       char  str[256];
  272.       int   str_len = ansi_str.Length();
  273.       if(str_len==0 || str_len >5)  return(false); // 2^8 = 256
  274.       strcpy( str, ansi_str.c_str() );
  276.       for( i=0; i<str_len; i++ )
  277.       {  ch = str[i];
  278.          if( ((ch>='0')&&(ch<='9')) || (ch=='+') || (ch=='-') || (ch==' ') )   continue;
  279.          break;
  280.       }
  281.       if( i!=str_len )
  282.          return(false);
  283.    }
  284.    /* convert string to integer */
  285.    double d_out_value = atof(ansi_str.c_str());
  286.    if( d_out_value >= pow(2.0, sizeof(signed char)*8-1) )  return false;
  287.   int int_out_value = ansi_str.ToInt();
  289.    /* chack value range */
  290.    if(range_min<=range_max)
  291.    {  if( (int_out_value<range_min)||(int_out_value>range_max) )
  292.          return(false);
  293.    }
  294.    out_value = (signed char) int_out_value & 0xFF;
  295.    return( true );
  296. }
  298. //---------------------------------------------------------------------------
  299. bool  AnsiString_To_UnsignedChar(AnsiString ansi_str, unsigned char &out_value, int range_min=0, int range_max=-1 )
  300. {
  301.    /* check if each char is valid */
  302.    {  int   i;
  303.       char  ch;
  304.       char  str[256];
  305.       int   str_len = ansi_str.Length();
  306.       if(str_len==0 || str_len >5)  return(false); // 2^8 = 256
  307.       strcpy( str, ansi_str.c_str() );
  309.       for( i=0; i<str_len; i++ )
  310.       {  ch = str[i];
  311.          if( ((ch>='0')&&(ch<='9')) || (ch=='+') || (ch=='-') || (ch==' ') )   continue;
  312.          break;
  313.       }
  314.       if( i!=str_len )
  315.          return(false);
  316.    }
  317.    /* convert string to integer */
  318.    double d_out_value = atof(ansi_str.c_str());
  319.    if( d_out_value >= pow(2.0, sizeof(unsigned char)*8) )  return false;
  321.   int int_out_value = ansi_str.ToInt();
  323.    /* chack value range */
  324.    if(range_min<=range_max)
  325.    {  if( (int_out_value<range_min)||(int_out_value>range_max) )
  326.          return(false);
  327.    }
  328.    out_value = (unsigned char) int_out_value & 0xFF;
  329.    return( true );
  330. }
  333. //---------------------------------------------------------------------------
  334. bool  AnsiString_To_msbsignchar(AnsiString ansi_str, signed char &out_value, int range_min=0, int range_max=-1 )
  335. {
  336.    /* check if each char is valid */
  337.      int   i;
  338.       unsigned char  ch;
  339.       char  str[256];
  340.       int int_out_value;
  341.       int   str_len = ansi_str.Length();
  342.       if(str_len==0 || str_len >5)  return(false); // 2^8 = 256
  343.       strcpy( str, ansi_str.c_str() );
  345.       for( i=0; i<str_len; i++ )
  346.       {  ch = str[i];
  347.          if( ((ch>='0')&&(ch<='9')) || (ch=='+') || (ch=='-') || (ch==' ') )   continue;
  348.          break;
  349.       }
  350.       if( i!=str_len )
  351.          return(false);
  354.    /* convert string to integer */
  355.    if( str[0] == '-' )
  356.    {
  357.         int_out_value = ansi_str.SubString(2, ansi_str.Length()).ToInt();
  358.    }
  359.    else
  360.    {
  361.         int_out_value = ansi_str.ToInt();
  362.    }
  364.    /* chack value range */
  365.    if(range_min<=range_max)
  366.    {  if( (int_out_value<range_min)||(int_out_value>range_max) )
  367.          return(false);
  368.    }
  370.    if( str[0] == '-' )
  371.    {
  372.         out_value = (signed char) int_out_value | 0x80;
  373.    }
  374.    else
  375.    {
  376.         out_value = (signed char) int_out_value;
  377.    }
  378.    return( true );
  379. }
  381. //---------------------------------------------------------------------------
  382. bool  AnsiString_To_msbUnsignedChar(AnsiString ansi_str, unsigned char &out_value, int range_min=0, int range_max=-1 )
  383. {
  384.    /* check if each char is valid */
  385.      int   i;
  386.       unsigned char  ch;
  387.       unsigned char  str[256];
  388.       int int_out_value;
  389.       int   str_len = ansi_str.Length();
  390.       if(str_len==0 || str_len >5)  return(false); // 2^8 = 256
  391.       strcpy( str, ansi_str.c_str() );
  393.       for( i=0; i<str_len; i++ )
  394.       {  ch = str[i];
  395.          if( ((ch>='0')&&(ch<='9')) || (ch=='+') || (ch=='-') || (ch==' ') )   continue;
  396.          break;
  397.       }
  398.       if( i!=str_len )
  399.          return(false);
  401.    /* convert string to integer */
  402.    if( str[0] == '-' )
  403.    {
  404.         int_out_value = ansi_str.SubString(2, ansi_str.Length()).ToInt();
  405.    }
  406.    else
  407.    {
  408.         int_out_value = ansi_str.ToInt();
  409.    }
  411.    /* chack value range */
  412.    if(range_min<=range_max)
  413.    {  if( (int_out_value<range_min)||(int_out_value>range_max) )
  414.          return(false);
  415.    }
  417.    if( str[0] == '-' )
  418.    {
  419.         out_value = (unsigned char) int_out_value | 0x80;
  420.    }
  421.    else
  422.    {
  423.         out_value = (unsigned char) int_out_value;
  424.    }
  425.    return( true );
  426. }
  428. //---------------------------------------------------------------------------
  429. bool  AnsiString_To_UnsignedBinary(AnsiString ansi_str, unsigned short &out_value, int range_min=0, int range_max=-1 )
  430. {
  431.     /* check if each char is valid */
  432.     int   i;
  433.       char  ch;
  434.       char  str[256];
  435.       int   str_len = ansi_str.Length();
  436.       if(str_len==0 || str_len >16)  return(false); // 2^8 = 256
  437.       strcpy( str, ansi_str.c_str() );
  439.       for( i=0; i<str_len; i++ )
  440.       {  ch = str[i];
  441.          if( ((ch>='0')&&(ch<='1')) )   continue;
  442.          break;
  443.       }
  444.       if( i!=str_len )
  445.          return(false);
  447.    /* convert string to integer */
  448.    int int_out_value=0;
  449.    int i_str;
  450.    for( i=0; i<str_len; i++ )
  451.    {
  452.         i_str = (int) str[i]-'0';
  453.         int_out_value += i_str*pow(2,str_len-i-1);
  454.    }
  456.    /* chack value range */
  457.    if(range_min<=range_max)
  458.    {  if( (int_out_value<range_min)||(int_out_value>range_max) )
  459.          return(false);
  460.    }
  461.    out_value = (unsigned short) int_out_value & 0xFFFF;
  462.    return( true );
  463. }
  465. //------------------------------------------------------------------------------
  466. bool  AnsiString_To_Float(AnsiString ansi_str, float &out_value, float range_min=0.0, float range_max=-1.0 )
  467. {
  468.    /* check if each char is valid */
  469.    {  int   i;
  470.       char  ch;
  471.       char  str[256];
  472.       int   str_len = ansi_str.Length();
  473.       if(str_len==0)  return(false);
  474.       strcpy( str, ansi_str.c_str() );
  476.       for( i=0; i<str_len; i++ )
  477.       {  ch = str[i];
  478.          if( ((ch>='0')&&(ch<='9')) || (ch=='.') || (ch=='+') || (ch=='-') || (ch==' ') )   continue;
  479.          break;
  480.       }
  481.       if( i!=str_len )
  482.          return(false);
  483.    }
  484.    /* convert string to integer */
  485.    out_value = (float) atof(ansi_str.c_str());
  487.    /* chack value range */
  488.    if(range_min<=range_max)
  489.    {  if( (out_value<range_min)||(out_value>range_max) )
  490.          return(false);
  491.    }
  492.    return( true );
  493. }
  495. //------------------------------------------------------------------------------
  496. bool  AnsiString_To_Double(AnsiString ansi_str, double &out_value, double range_min=0.0, double range_max=-1.0 )
  497. {
  498.    /* check if each char is valid */
  499.    {  int   i;
  500.       char  ch;
  501.       char  str[256];
  502.       int   str_len = ansi_str.Length();
  503.       if(str_len==0)  return(false);
  504.       strcpy( str, ansi_str.c_str() );
  506.       for( i=0; i<str_len; i++ )
  507.       {  ch = str[i];
  508.          if( ((ch>='0')&&(ch<='9')) || (ch=='.') || (ch=='+') || (ch=='-') || (ch==' ') )   continue;
  509.          break;
  510.       }
  511.       if( i!=str_len )
  512.          return(false);
  513.    }
  514.    /* convert string to integer */
  515.    out_value = atof(ansi_str.c_str());
  517.    /* chack value range */
  518.    if(range_min<=range_max)
  519.    {  if( (out_value<range_min)||(out_value>range_max) )
  520.          return(false);
  521.    }
  522.    return( true );
  523. }
  525. //---------------------------------------------------------------------------
  526. bool  AnsiString_Hex_To_UnsignedChar(AnsiString ansi_str, unsigned char &out_value ,int range_min=0, int range_max=-1 )
  527. {
  528.    char  str[256];
  529.    unsigned  char  val;
  531.    /* check if each char is valid */
  532.    {  int   i;
  533.       unsigned char  ch;
  534.       int   str_len = ansi_str.Length();
  535.       if(str_len==0)  return(false);
  536.       strcpy( str, ansi_str.c_str() );
  538.       val = 0;
  539.       for( i=0; i<str_len; i++ )
  540.       {  ch = str[i];
  541.          if( (ch>='0')&&(ch<='9') )
  542.          {  val <<= 4;
  543.             val += ch-'0';
  544.          }
  545.          else if( (ch>='A')&&(ch<='F') )
  546.          {  val <<= 4;
  547.             val += ch-'A'+10;
  548.          }
  549.          else if( (ch>='a')&&(ch<='f') )
  550.          {  val <<= 4;
  551.             val += ch-'a'+10;
  552.          }
  553.          else if( ch==' ' )
  554.          {
  555.          }
  556.          else
  557.          {  break;
  558.          }
  559.          continue;
  560.       }
  561.       if( i!=str_len )
  562.          return(false);
  563.    }
  565.    /* chack value range */
  566.    if(range_min<=range_max)
  567.    {  if( (val<range_min)||(val>range_max) )
  568.          return(false);
  569.    }
  570.    /* convert string to integer */
  571.    out_value = val;
  573.    return( true );
  574. }
  576. //---------------------------------------------------------------------------
  577. bool  AnsiString_Hex_To_Int(AnsiString ansi_str, int &out_value )
  578. {
  579.    char  str[256];
  580.    int  val;
  582.    /* check if each char is valid */
  583.    {  int   i;
  584.       char  ch;
  585.       int   str_len = ansi_str.Length();
  586.       if(str_len==0)  return(false);
  587.       strcpy( str, ansi_str.c_str() );
  589.       val = 0;
  590.       for( i=0; i<str_len; i++ )
  591.       {  ch = str[i];
  592.          if( (ch>='0')&&(ch<='9') )
  593.          {  val <<= 4;
  594.             val += ch-'0';
  595.          }
  596.          else if( (ch>='A')&&(ch<='F') )
  597.          {  val <<= 4;
  598.             val += ch-'A'+10;
  599.          }
  600.          else if( (ch>='a')&&(ch<='f') )
  601.          {  val <<= 4;
  602.             val += ch-'a'+10;
  603.          }
  604.          else if( ch==' ' )
  605.          {
  606.          }
  607.          else
  608.          {  break;
  609.          }
  610.          continue;
  611.       }
  612.       if( i!=str_len )
  613.          return(false);
  614.    }
  615.    /* convert string to integer */
  616.    out_value = val;
  618.    return( true );
  619. }
  621. //---------------------------------------------------------------------------
  622. bool  AnsiString_Hex_To_UnsignedShort(AnsiString ansi_str, unsigned short &out_value )
  623. {
  624.    char  str[256];
  625.    unsigned  short  val;
  627.    /* check if each char is valid */
  628.    {  int   i;
  629.       char  ch;
  630.       int   str_len = ansi_str.Length();
  631.       if(str_len==0)  return false;
  632.       strcpy( str, ansi_str.c_str() );
  634.       val = 0;
  635.       for( i=0; i<str_len; i++ )
  636.       {  ch = str[i];
  637.          if( (ch>='0')&&(ch<='9') )
  638.          {  val <<= 4;
  639.             val += ch-'0';
  640.          }
  641.          else if( (ch>='A')&&(ch<='F') )
  642.          {  val <<= 4;
  643.             val += ch-'A'+10;
  644.          }
  645.          else if( (ch>='a')&&(ch<='f') )
  646.          {  val <<= 4;
  647.             val += ch-'a'+10;
  648.          }
  649.          else if( ch==' ' )
  650.          {
  651.          }
  652.          else
  653.          {  break;
  654.          }
  655.          continue;
  656.       }
  657.       if( i!=str_len )
  658.          return false;
  659.    }
  660.    /* convert string to integer */
  661.    out_value = val;
  663.    return( true );
  664. }
  666. //---------------------------------------------------------------------------
  667. bool  AnsiString_Hex_To_UnsignedInt(AnsiString ansi_str, unsigned  int &out_value )
  668. {
  669.    char  str[256];
  670.    unsigned  int  val;
  672.    /* check if each char is valid */
  673.    {  int   i;
  674.       char  ch;
  675.       int   str_len = ansi_str.Length();
  676.       if(str_len==0)  return(false);
  677.       strcpy( str, ansi_str.c_str() );
  679.       val = 0;
  680.       for( i=0; i<str_len; i++ )
  681.       {  ch = str[i];
  682.          if( (ch>='0')&&(ch<='9') )
  683.          {  val <<= 4;
  684.             val += ch-'0';
  685.          }
  686.          else if( (ch>='A')&&(ch<='F') )
  687.          {  val <<= 4;
  688.             val += ch-'A'+10;
  689.          }
  690.          else if( (ch>='a')&&(ch<='f') )
  691.          {  val <<= 4;
  692.             val += ch-'a'+10;
  693.          }
  694.          else if( ch==' ' )
  695.          {
  696.          }
  697.          else
  698.          {  break;
  699.          }
  700.          continue;
  701.       }
  702.       if( i!=str_len )
  703.          return(false);
  704.    }
  705.    /* convert string to integer */
  706.    out_value = val;
  708.    return( true );
  709. }
  711. //---------------------------------------------------------------------------
  712. bool  AnsiString_Hex_To_Long(AnsiString ansi_str, unsigned long &out_value )
  713. {
  714.    char  str[256];
  715.    long  val;
  717.    /* check if each char is valid */
  718.    {  int   i;
  719.       char  ch;
  720.       int   str_len = ansi_str.Length();
  721.       if(str_len==0)  return(false);
  722.       strcpy( str, ansi_str.c_str() );
  724.       val = 0;
  725.       for( i=0; i<str_len; i++ )
  726.       {  ch = str[i];
  727.          if( (ch>='0')&&(ch<='9') )
  728.          {  val <<= 4;
  729.             val += ch-'0';
  730.          }
  731.          else if( (ch>='A')&&(ch<='F') )
  732.          {  val <<= 4;
  733.             val += ch-'A'+10;
  734.          }
  735.          else if( (ch>='a')&&(ch<='f') )
  736.          {  val <<= 4;
  737.             val += ch-'a'+10;
  738.          }
  739.          else if( ch==' ' )
  740.          {
  741.          }
  742.          else
  743.          {  break;
  744.          }
  745.          continue;
  746.       }
  747.       if( i!=str_len )
  748.          return(false);
  749.    }
  750.    /* convert string to integer */
  751.    out_value = val;
  753.    return( true );
  754. }
  757. //==============================================================================
  758. bool  CharArray_To_Float( Char* str, int str_len, float &out_value, float range_min=0.0, float range_max=-1.0 )
  759. {
  760.    /* check if each char is valid */
  761.    {  int   i;
  762.       char  ch;
  763.       //char  str[256];
  764.       //int   str_len = ansi_str.Length();
  765.       if(str_len==0)  return(false);
  766.       out_value = 0.0;
  767.       //strcpy( str, ansi_str.c_str() );
  769.       //for( i=0; i<str_len; i++ )
  770.      // {  ch = *(str+i);
  771.      //    if( ((ch>='0')&&(ch<='9')) || (ch=='.') || (ch=='+') || (ch=='-') || (ch==' ') )   continue;
  772.       //   break;
  773.      // }
  774.       for( i=0; i<str_len; i++ )
  775.       {  ch = *(str+i);
  776.          if( ((ch>='0')&&(ch<='9')) )
  777.          {
  778.              out_value = (out_value*10.0) + ch;
  779.          }
  780.          // || (ch=='.') || (ch=='+') || (ch=='-') || (ch==' ') )   continue;
  781.          break;
  782.       }
  783.       if( i!=str_len )
  784.          return(false);
  785.    }
  786.    /* convert string to integer */
  787.   // out_value = (float) atof(ansi_str.c_str());
  789.    /* chack value range */
  790.    if(range_min<=range_max)
  791.    {  if( (out_value<range_min)||(out_value>range_max) )
  792.          return(false);
  793.    }
  794.    return( true );
  795. }
  801. //===========================================================================
  802. int   _ArrayString_Parse( char *src, char* dst, short* dst_pos )
  803. {
  804.    char  ch = src[0];
  805.    char  last_char_is_null = 1;
  806.    int   dst_idx = 0;
  807.    int   i;
  809.    for( i=0; (ch!=0)&&(i<2047); i++ )
  810.    {
  811.       ch = src[i];
  812.       if(  ((ch>='0')&&(ch<='9'))||(ch=='-')||(ch=='+')||(ch=='.')||(ch=='E') ||(ch=='e'))
  813.       {  if( last_char_is_null )
  814.          {  dst_pos[dst_idx] = i;
  815.             dst_idx++;
  816.          }
  817.          dst[i] = ch;
  818.          last_char_is_null = 0;
  819.       }
  820.       else
  821.       {  dst[i] = 0;
  822.          last_char_is_null = 1;
  823.       }
  824.    }
  825.    dst[i] = 0;
  826.    dst_pos[dst_idx] = -1;
  827.    return( dst_idx );
  828. }
  830. //---------------------------------------------------------------------------
  831. int   Hex_ArrayString_Parse( char *src, char* dst, short* dst_pos )
  832. {
  833.    char  ch = src[0];
  834.    char  last_char_is_null = 1;
  835.    int   dst_idx = 0;
  836.    int   i;
  838.    for( i=0; (ch!=0)&&(i<2047); i++ )
  839.    {
  840.       ch = src[i];
  841.       if( ((ch>='0')&&(ch<='9')) ||
  842.           ((ch>='A')&&(ch<='F')) ||
  843.           ((ch>='a')&&(ch<='f')) ||
  844.           (ch=='-')              ||
  845.           (ch=='+')              ||
  846.           (ch=='.')
  847.         )
  848.       {  if( last_char_is_null )
  849.          {  dst_pos[dst_idx] = i;
  850.             dst_idx++;
  851.          }
  852.          dst[i] = ch;
  853.          last_char_is_null = 0;
  854.       }
  855.       else
  856.       {  dst[i] = 0;
  857.          last_char_is_null = 1;
  858.       }
  859.    }
  860.    dst[i] = 0;
  861.    dst_pos[dst_idx] = -1;
  862.    return( dst_idx );
  863. }
  865. //---------------------------------------------------------------------------
  866. bool  double_To_Array_ASCII_char( double d, char* array  )
  867. {
  868.     AnsiString as_d = Double_To_AnsiString( d );
  869.     int i;
  871.     for( i=0; i<as_d.Length(); i++)
  872.     {
  873.         strcpy( (array+i), as_d.SubString(i+1,1).c_str());
  874.     }
  875.     *(array+i) = '';
  877.     return true;
  878. }
  880. //---------------------------------------------------------------------------
  881. void  ASCII_char_To_Array_double( char* array, double &d  )
  882. {
  883.     for(int i=0; ; i++)
  884.     {
  885.         if( *(array+i) == '' )  break;
  886.         *(array+i) &= 0x7F;
  887.     }
  888.     AnsiString as_d(array);
  890.     d = atof(as_d.c_str());
  891. }
  893. //---------------------------------------------------------------------------
  894. int   String_To_Array_Char( char *src, char* array, int max_count )
  895. {
  896.     char  str[2048];
  897.     short str_pos[512];
  898.     int   i, count;
  900.     count = _ArrayString_Parse( src, str, str_pos );
  901.     if( count>max_count )  count = max_count;
  903.     for(i=0; i<count; i++)
  904.     {  array[i] = (char) atoi( &str[str_pos[i]] );
  905.     }
  907.     return( count );
  908. }
  910. //---------------------------------------------------------------------------
  911. int   String_To_Array_UnsignedChar( char *src, unsigned char* array, int max_count )
  912. {
  913.    char  str[2048];
  914.    short str_pos[512];
  915.    int   i, count;
  917.    count = _ArrayString_Parse( src, str, str_pos );
  918.    if( count>max_count )  count = max_count;
  920.    for(i=0; i<count; i++)
  921.    {  array[i] = (unsigned char) atoi( &str[str_pos[i]] );
  922.    }
  923.    return( count );
  924. }
  926. //---------------------------------------------------------------------------
  927. int   AnsiString_Hex_To_Array_UnsignedChar(AnsiString as_str, unsigned char* array, int max_count, char c_sep )
  928. {
  929.    char  str[2048];
  930.    char  ch;
  931.    short str_pos[512];
  932.    int   i, count;
  933.    unsigned  char  val;
  934.   // AnsiString as_str(src);
  935.   // count = Hex_ArrayString_Parse( src, str, str_pos );
  936.   // count = Get_CharAppearCount( as_str, ',' );
  937.    count = Get_CharAppearCount( as_str, c_sep );
  938.    if( count>max_count )  count = max_count;
  940.    for(i=0; i<=count; i++)
  941.    {
  942.        // int iLD_l = as_str.AnsiPos(",");
  943.         int iLD_l = as_str.AnsiPos( c_sep );
  944.         if( iLD_l != 0 )
  945.         {
  946.             AnsiString_Hex_To_UnsignedChar( as_str.SubString( 1, iLD_l-1), array[i]  );
  947.         }
  948.         else
  949.         {   AnsiString_Hex_To_UnsignedChar( as_str, array[i]  );
  950.         }
  951.         as_str = as_str.SubString( iLD_l+1, as_str.Length() - iLD_l );
  953.    }
  954.    return( count );
  955. }
  956. //---------------------------------------------------------------------------
  957. int   String_To_Array_UnsignedShort( char *src, unsigned short* array, int max_count )
  958. {
  959.    char  str[2048];
  960.    short str_pos[512];
  961.    int   i, count;
  963.    count = _ArrayString_Parse( src, str, str_pos );
  964.    if( count>max_count )  count = max_count;
  966.    for(i=0; i<count; i++)
  967.    {  array[i] = (unsigned short) atoi( &str[str_pos[i]] );
  968.    }
  969.    return( count );
  970. }
  973. //---------------------------------------------------------------------------
  974. int   String_To_Array_short( char *src, short* array, int max_count )
  975. {
  976.    char  str[2048];
  977.    short str_pos[512];
  978.    int   i, count;
  980.    count = _ArrayString_Parse( src, str, str_pos );
  981.    if( count>max_count )  count = max_count;
  983.    for(i=0; i<count; i++)
  984.    {  array[i] = (short)atoi( &str[str_pos[i]] );
  985.    }
  986.    return( count );
  987. }
  989. //---------------------------------------------------------------------------
  990. int   String_To_Array_int( char *src, int* array, int max_count )
  991. {
  992.    char  str[2048];
  993.    short str_pos[512];
  994.    int   i, count;
  996.    count = _ArrayString_Parse( src, str, str_pos );
  997.    if( count>max_count )  count = max_count;
  999.    for(i=0; i<count; i++)
  1000.    {  array[i] = atoi( &str[str_pos[i]] );
  1001.    }
  1002.    return( count );
  1003. }
  1005. //---------------------------------------------------------------------------
  1006. int   String_To_Array_UnsignedInteger( char *src, unsigned int* array, int max_count )
  1007. {
  1008.    char  str[2048];
  1009.    short str_pos[512];
  1010.    int   i, count;
  1012.    count = _ArrayString_Parse( src, str, str_pos );
  1013.    if( count>max_count )  count = max_count;
  1015.    for(i=0; i<count; i++)
  1016.    {  array[i] = ( unsigned int) atoi( &str[str_pos[i]] );
  1017.    }
  1018.    return( count );
  1019. }
  1021. //---------------------------------------------------------------------------
  1022. int   String_To_Array_long( char *src, long* array, int max_count )
  1023. {
  1024.    char  str[2048];
  1025.    short str_pos[512];
  1026.    int   i, count;
  1028.    count = _ArrayString_Parse( src, str, str_pos );
  1029.    if( count>max_count )  count = max_count;
  1031.    for(i=0; i<count; i++)
  1032.    {  array[i] = atol( &str[str_pos[i]] );
  1033.    }
  1034.    return( count );
  1035. }
  1037. //---------------------------------------------------------------------------
  1038. int   String_To_Array_float( char *src, float* array, int max_count )
  1039. {
  1040.    char  str[2048];
  1041.    short str_pos[512];
  1042.    int   i, count;
  1044.    count = _ArrayString_Parse( src, str, str_pos );
  1045.    if( count>max_count )  count = max_count;
  1047.    for(i=0; i<count; i++)
  1048.    {  array[i] = (float)atof( &str[str_pos[i]] );
  1049.    }
  1050.    return( count );
  1051. }
  1053. //---------------------------------------------------------------------------
  1054. int   String_To_Array_double( char *src, double* array, int max_count )
  1055. {
  1056.    char  str[2048];
  1057.    short str_pos[512];
  1058.    int   i, count;
  1060.    count = _ArrayString_Parse( src, str, str_pos );
  1061.    if( count>max_count )  count = max_count;
  1063.    for(i=0; i<count; i++)
  1064.    {  array[i] = atof( &str[str_pos[i]] );
  1065.    }
  1066.    return( count );
  1067. }
  1069. //===========================================================================
  1070. int   Array_To_String_Char( char *str, char* array, int count, char separate_char )
  1071. {
  1072.     char  *ptr = str;
  1073.     int   i;
  1075.     for( i=0; i<count-1; i++ )
  1076.     {   ptr += sprintf( ptr, "%d%c", (char)array[i], separate_char );
  1077.     }
  1078.     ptr += sprintf( ptr, "%d", (char)array[i] );
  1079.     i = (int)((unsigned long)ptr - (unsigned long)str);
  1081.     return i;
  1082. }
  1084. //--------------------------------------------------------------------------
  1085. int   Array_To_String_UnsignedChar( char *str, unsigned char* array, int count, char separate_char )
  1086. {
  1087.    char  *ptr = str;
  1088.    int   i;
  1090.    for( i=0; i<count-1; i++ )
  1091.    {  ptr += sprintf( ptr, "%d%c", (unsigned char)array[i], separate_char );
  1092.    }
  1093.    ptr += sprintf( ptr, "%d", (unsigned char)array[i] );
  1094.    i = (int)((unsigned long)ptr - (unsigned long)str);
  1096.    return( i );
  1097. }
  1099. //--------------------------------------------------------------------------
  1100. int   Array_To_String_UnsignedShort( char *str, unsigned short* array, int count, char separate_char )
  1101. {
  1102.    char  *ptr = str;
  1103.    int   i;
  1105.    for( i=0; i<count-1; i++ )
  1106.    {  ptr += sprintf( ptr, "%d%c", (unsigned short)array[i], separate_char );
  1107.    }
  1108.    ptr += sprintf( ptr, "%d", (unsigned short)array[i] );
  1109.    i = (int)((unsigned long)ptr - (unsigned long)str);
  1111.    return( i );
  1112. }
  1114. //--------------------------------------------------------------------------
  1115. int   Array_To_String_short( char *str, short* array, int count, char separate_char )
  1116. {
  1117.    char  *ptr = str;
  1118.    int   i;
  1120.    for( i=0; i<count-1; i++ )
  1121.    {  ptr += sprintf( ptr, "%d%c", (int)array[i], separate_char );
  1122.    }
  1123.    ptr += sprintf( ptr, "%d", (int)array[i] );
  1124.    i = (int)((unsigned long)ptr - (unsigned long)str);
  1126.    return( i );
  1127. }
  1129. //---------------------------------------------------------------------------
  1130. int   Array_To_String_UnsignedInteger( char *str, unsigned int* array, int count, char separate_char )
  1131. {
  1132.    char  *ptr = str;
  1133.    int   i;
  1135.    for( i=0; i<count-1; i++ )
  1136.    {  ptr += sprintf( ptr, "%d%c", array[i], separate_char );
  1137.    }
  1138.    ptr += sprintf( ptr, "%d", array[i] );
  1139.    i = (unsigned int)((unsigned long)ptr - (unsigned long)str);
  1141.    return( i );
  1142. }
  1144. //---------------------------------------------------------------------------
  1145. int   Array_To_String_int( char *str, int* array, int count, char separate_char )
  1146. {
  1147.    char  *ptr = str;
  1148.    int   i;
  1150.    for( i=0; i<count-1; i++ )
  1151.    {  ptr += sprintf( ptr, "%d%c", array[i], separate_char );
  1152.    }
  1153.    ptr += sprintf( ptr, "%d", array[i] );
  1154.    i = (int)((unsigned long)ptr - (unsigned long)str);
  1156.    return( i );
  1157. }
  1159. //---------------------------------------------------------------------------
  1160. int   Array_To_String_long( char *str, long* array, int count, char separate_char )
  1161. {
  1162.    char  *ptr = str;
  1163.    int   i;
  1165.    for( i=0; i<count-1; i++ )
  1166.    {  ptr += sprintf( ptr, "%l%c", array[i], separate_char );
  1167.    }
  1168.    ptr += sprintf( ptr, "%l", array[i] );
  1169.    i = (int)((unsigned long)ptr - (unsigned long)str);
  1171.    return( i );
  1172. }
  1174. //---------------------------------------------------------------------------
  1175. int   Array_To_String_float( char *str, float* array, int count, char separate_char )
  1176. {
  1177.    char  *ptr = str;
  1178.    int   i;
  1180.    for( i=0; i<count-1; i++ )
  1181.    {  ptr += sprintf( ptr, "%.3f%c", array[i], separate_char );
  1182.    }
  1183.    ptr += sprintf( ptr, "%.3f%c", array[i], '0' );
  1184.    i = (int)((unsigned long)ptr - (unsigned long)str);
  1186.    return( i );
  1187. }
  1189. //===========================================================================
  1190. int   Array_To_Hex_String_UnsignedChar( char *str, unsigned char* array, int count, char separate_char )
  1191. {
  1192.    char  *ptr = str;
  1193.    int   i;
  1195.    for( i=0; i<count-1; i++ )
  1196.    {  ptr += sprintf( ptr, "%X%c", (unsigned char)array[i], separate_char );
  1197.    }
  1198.    ptr += sprintf( ptr, "%X", (unsigned char)array[i] );
  1199.    i = (int)((unsigned long)ptr - (unsigned long)str);
  1201.    return( i );
  1202. }
  1203. //---------------------------------------------------------------------------
  1204. bool AnsiString_To_dBm( AnsiString asStr, ViReal64* virTx )
  1205. {
  1206.     bool result;
  1208.     AnsiString asBase, asExponent;
  1210.     result = getBaseFromStr( asStr, asBase );
  1211.     if( result == false )  return false;
  1213.     result = getExponentFromStr( asStr, asExponent );
  1214.     if( result == false )  return false;
  1216.     if( (asExponent.SubString(1,1)).AnsiCompareIC( "+" ) == 0 )
  1217.     {
  1218.         *virTx = asBase.ToInt() * asExponent.ToInt();
  1219.     }
  1220.     return true;
  1221. }
  1223. //===========================================================================
  1224. static const int  pcl2power_table[][32] =
  1225. {  //  0  1  2  3  4  5  6  7  8  9  0  1  2  3  4  5  6  7  8  9  0  1  2  3  4  5  6  7  8  9  0  1
  1226.    {  39,39,39,37,35,33,31,29,27,25,23,21,19,17,15,13,11, 9, 7, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5  },  // GSM900
  1227.    {  30,28,26,24,22,20,18,16,14,12,10, 8, 6, 4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,36,34,32  },  // DCS1800
  1228.    {  30,28,26,24,22,20,18,16,14,12,10, 8, 6, 4, 2, 0, 0, 0, 0, 0, 0, 0,33,33,33,33,33,33,33,33,33,32  },  // PCS1900
  1229.    {  39,39,39,37,35,33,31,29,27,25,23,21,19,17,15,13,11, 9, 7, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5  },  // GSM850
  1231. };
  1233. //---------------------------------------------------------------------------
  1234. int  PCL2POWER( int band, int pcl )
  1235. {  if(pcl<0)  pcl=0;
  1236.    if(pcl>31) pcl = 31;
  1237.    int  power=pcl2power_table[band][pcl];
  1238.    return(power);
  1239. }
  1241. //---------------------------------------------------------------------------
  1242. static const int  power2pcl_table[][32] =
  1243. {  //  0  1  2  3  4  5  6  7  8  9  0  1  2  3  4  5  6  7  8
  1244.    {  19,18,17,16,15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 2  },  // GSM900
  1245.    {  15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0,31,30,29  },  // DCS1800
  1246.    {  15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0,31,30,29  },  // PCS1900
  1247.    {  19,18,17,16,15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 2  },  // GSM850
  1248. };
  1250. //---------------------------------------------------------------------------
  1251. int  POWER2PCL( int band, int power )
  1252. {
  1253.    if(band == BANDSEL_GSM900 || band==BANDSEL_GSM850)  power -= 5;
  1254.    power/=2;
  1255.    if(power<0)  power = 0;
  1256.    if(power>31)  power = 31;
  1257.    int pcl = power2pcl_table[band][power];
  1258.    return(pcl);
  1259. }