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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
hxstrfmt.cpp
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：12k
源码类别：

Symbian

开发平台：

C/C++

hxstrfmt.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. #include "hxstring.h"
  37. #include "hxassert.h"
  39. #include "hlxclib/string.h"
  40. #include "safestring.h"
  41. #include "hlxclib/stdarg.h"
  42. #include "hxassert.h"
  44. static const int AlternateFlag   = 0x01;
  45. static const int ZeroPadFlag     = 0x02;
  46. static const int LeftJustifyFlag = 0x04;
  47. static const int AddSpaceFlag    = 0x08;
  48. static const int AddSignFlag     = 0x10;
  50. static const int MaxWidthSize = 12;
  51. static const int WidthParam = -2;
  52. static const int WidthError = -3;
  54. static const int MaxPrecisionSize = 12;
  55. static const int NoPrecision    = -1;
  56. static const int PrecisionParam = -2;
  57. static const int PrecisionError = -3;
  59. static const int NoLength = 0;
  60. static const int ShortLength = 1;
  61. static const int LongLength = 2;
  63. static const int MaxConversionSize = 32;
  64. static const int MaxFormatSize = 11;
  66. static int GetFlags(const char*& pCur)
  67. {
  68.     int ret = 0;
  70.     for (; *pCur && strchr("#0- +", *pCur); pCur++)
  71.     {
  72. switch(*pCur) {
  73. case '#':
  74.     ret |= AlternateFlag;
  75.     break;
  77. case '0':
  78.     ret |= ZeroPadFlag;
  79.     break;
  81. case '-':
  82.     ret |= LeftJustifyFlag;
  83.     break;
  85. case ' ':
  86.     ret |= AddSpaceFlag;
  87.     break;
  88.     
  89. case '+':
  90.     ret |= AddSignFlag;
  91.     break;
  92. };
  93.     }
  95.     return ret;
  96. }
  98. static int GetWidth(const char*& pCur)
  99. {
  100.     int ret = 1;
  102.     if (*pCur)
  103.     {
  104. if (*pCur == '*')
  105. {
  106.     // The width is specified as a parameter
  107.     pCur++;
  108.     ret = WidthParam;
  109. }
  110. else
  111. {
  112.     if (strchr("123456789", *pCur))
  113.     {
  114. int i = 0;
  115. char widthBuf[MaxWidthSize]; /* Flawfinder: ignore */
  117. widthBuf[i++] = *pCur++;
  119. for(; (i < MaxWidthSize) && 
  120. *pCur && (strchr("0123456789", *pCur)); i++)
  121.     widthBuf[i] = *pCur++;
  123. if (i != MaxWidthSize)
  124. {
  125.     widthBuf[i] = '';
  127.     char* pEnd = 0;
  128.     long int tmp = strtol(widthBuf, &pEnd, 10);
  129.     
  130.     if (widthBuf[0] && !*pEnd)
  131. ret = (int)tmp;
  132. }
  133. else
  134.     ret = WidthError;
  135.     }
  136. }
  137.     }
  139.     return ret;
  140. }
  142. static int GetPrecision(const char*& pCur)
  143. {
  144.     int ret = NoPrecision;
  146.     if (*pCur == '.')
  147.     {
  148. pCur++;
  150. if (*pCur == '*')
  151. {
  152.     // The width is specified as a parameter
  153.     pCur++;
  154.     ret = PrecisionParam;
  155. }
  156. else
  157. {
  158.     int i = 0;
  159.     char precisionBuf[MaxPrecisionSize]; /* Flawfinder: ignore */
  160.     
  161.     for(; (i < MaxPrecisionSize) && 
  162.     *pCur && (strchr("0123456789", *pCur)); i++)
  163. precisionBuf[i] = *pCur++;
  164.     
  165.     if (i != MaxPrecisionSize)
  166.     {
  167. precisionBuf[i] = '';
  168.     
  169. if (strlen(precisionBuf))
  170. {
  171.     char* pEnd = 0;
  172.     long int tmp = strtol(precisionBuf, &pEnd, 10);
  173.     
  174.     if (precisionBuf[0] && !*pEnd)
  175. ret = (int)tmp;
  176. }
  177. else
  178.     ret = 0;
  179.     }
  180.     else
  181. ret = PrecisionError;
  182. }
  183.     }
  185.     return ret;
  186. }
  188. static int GetLength(const char*& pCur)
  189. {
  190.     int ret = NoLength;
  192.     switch(*pCur) {
  193.     case 'l':
  194. ret = LongLength;
  195. pCur++;
  196. break;
  197.     case 'h':
  198. ret = ShortLength;
  199. pCur++;
  200. break;
  201.     };
  203.     return ret;
  204. }
  206. static void ConstructFormat(char* fmt, char type, int flags, int length,
  207.     int precision)
  208. {
  209.     int i = 0;
  210.     fmt[i++] = '%';
  212.     if (flags & AlternateFlag)
  213. fmt[i++] = '#';
  215.     if (flags & LeftJustifyFlag)
  216. fmt[i++] = '-';
  218.     if (flags & AddSpaceFlag)
  219. fmt[i++] = ' ';
  221.     if (flags & AddSignFlag)
  222. fmt[i++] = '+';
  224.     if (flags & ZeroPadFlag)
  225. fmt[i++] = '0';
  227.     fmt[i++] = '*';
  229.     if (precision != NoPrecision)
  230.     {
  231. fmt[i++] = '.';
  232. fmt[i++] = '*';
  233.     }
  235.     if (length == ShortLength)
  236. fmt[i++] = 'h';
  237.     
  238.     if (length == LongLength)
  239. fmt[i++] = 'l';
  242.     fmt[i++] = type;
  243.     fmt[i] = '';
  245.     HX_ASSERT(i < MaxFormatSize);
  246. }
  248. // This could be handled with a single template function, but for now
  249. // we can't use templates. :( 
  250. // I'll use a macro instead.
  252. #define CONVERT_FUNC_DEF(funcName, convertType)                    
  253. static int funcName(const char* fmt,                               
  254.                     int width, int precision,                      
  255.                     convertType value)                             
  256. {                                                                  
  257.     int ret = 0;                                                   
  258.     int bufSize = width + MaxConversionSize;                       
  259.                                                                    
  260.     if (precision != NoPrecision)                                  
  261.         bufSize += precision;                                      
  262.     char* pBuf = new char[bufSize];                                
  263.     if (precision == NoPrecision)                                  
  264. ret = SafeSprintf(pBuf, bufSize, fmt, width, value);       
  265.     else                                                           
  266. ret = SafeSprintf(pBuf, bufSize, fmt, width, precision, value); 
  267.     HX_ASSERT(ret < bufSize);                                      
  268.     delete [] pBuf;                                                
  269.     return ret;                                                    
  270. }
  272. CONVERT_FUNC_DEF(ConvertInt, int)
  273. CONVERT_FUNC_DEF(ConvertShort, short int)
  274. CONVERT_FUNC_DEF(ConvertLong, long int)
  275. CONVERT_FUNC_DEF(ConvertUInt, unsigned int)
  276. CONVERT_FUNC_DEF(ConvertUShort, unsigned short int)
  277. CONVERT_FUNC_DEF(ConvertULong, unsigned long int)
  278. CONVERT_FUNC_DEF(ConvertDouble, double)
  279. CONVERT_FUNC_DEF(ConvertChar, char)
  280. CONVERT_FUNC_DEF(ConvertWChar, wchar_t)
  281. CONVERT_FUNC_DEF(ConvertPtr, void*)
  283. static bool ParseFormat(const char*& pCur, int& charCount, va_list& args)
  284. {
  285.     bool ret = true;
  287.     const char* pTmp = pCur;
  289.     int flags = GetFlags(pTmp);
  290.     int width = 1;
  291.     int precision = NoPrecision;
  292.     int convertSize = 0;
  294.     if ((width = GetWidth(pTmp)) == WidthError)
  295.     {
  296. HX_ASSERT(!fprintf(stderr, "Width field too long '%s'n", pCur));
  297. ret = false;
  298.     }
  299.     else if ((precision = GetPrecision(pTmp)) == PrecisionError)
  300.     {
  301. HX_ASSERT(!fprintf(stderr, "Precision field too long '%s'n", pCur));
  302. ret = false;
  303.     }
  304.     else
  305.     {
  306. int length = GetLength(pTmp);
  307. char type = *pTmp++;
  309. if (width == WidthParam)
  310. {
  311.     width = va_arg(args, int);
  312.     if (width < 0)
  313.     {
  314. width = -width;
  315. flags |= LeftJustifyFlag;
  316.     }
  317. }
  319. if (precision == PrecisionParam)
  320. {
  321.     precision = va_arg(args, int);
  323.     if (precision < 0)
  324. precision = 0;
  325. }
  327. switch (type) {
  328. case 's':
  329. {
  330.     const char* pVal = va_arg(args, const char*);
  331.     if (length == LongLength)
  332.     {
  333. HX_ASSERT(!"Wide characters not supported");
  335. // Make up something large and hope that it's big enough
  336. convertSize = 512;
  337.     }
  338.     else
  339.     {
  340. if (precision >= 0)
  341. {
  342.     for(; (convertSize < precision) && 
  343.     pVal[convertSize]; convertSize++);
  344. }
  345. else
  346.     convertSize = strlen(pVal);
  347.     }
  348. }break;
  350. case 'd':
  351. case 'i':
  352. {
  353.     char fmt[MaxFormatSize]; /* Flawfinder: ignore */
  355.     ConstructFormat(fmt, type, flags, length, precision);
  357.     if (length == LongLength)
  358.     {
  359. long int val = va_arg(args, long int);
  360. convertSize = ConvertLong(fmt, width, precision, val);
  361.     }
  362.     else if (length == ShortLength)
  363.     {
  364. short int val = va_arg(args, int);
  365. convertSize = ConvertShort(fmt, width, precision, val);
  366.     }
  367.     else
  368.     {
  369. int val = va_arg(args, int);
  370. convertSize = ConvertInt(fmt, width, precision, val);;
  371.     }
  372. }break;
  374. case 'u':
  375. case 'o':
  376. case 'x':
  377. case 'X':
  378. {
  379.     char fmt[MaxFormatSize]; /* Flawfinder: ignore */
  381.     ConstructFormat(fmt, type, flags, length, precision);
  383.     if (length == LongLength)
  384.     {
  385. unsigned long int val = va_arg(args, unsigned long int);
  386. convertSize = ConvertULong(fmt, width, precision, val);
  387.     }
  388.     else if (length == ShortLength)
  389.     {
  390. unsigned short int val = va_arg(args, unsigned int);
  391. convertSize = ConvertUShort(fmt, width, precision, val);
  392.     }
  393.     else
  394.     {
  395. unsigned int val = va_arg(args, unsigned int);
  396. convertSize = ConvertUInt(fmt, width, precision, val);
  397.     }
  398. }break;
  400. case 'e':
  401. case 'E':
  402. case 'f':
  403. case 'g':
  404. case 'G':
  405. {
  406.     char fmt[MaxFormatSize]; /* Flawfinder: ignore */
  408.     ConstructFormat(fmt, type, flags, length, precision);
  410.     double val = va_arg(args, double);
  411.     convertSize = ConvertDouble(fmt, width, precision, val);
  412. }break;
  414. case 'c':
  415. {
  416.     char fmt[MaxFormatSize]; /* Flawfinder: ignore */
  418.     ConstructFormat(fmt, type, flags, length, precision);
  420.     if (length == LongLength)
  421.     {
  422. wchar_t val = va_arg(args, int);
  423. convertSize = ConvertWChar(fmt, width, precision, val);
  424.     }
  425.     else
  426.     {
  427. char val = va_arg(args, int);
  428. convertSize = ConvertChar(fmt, width, precision, val);
  429.     }
  430. }break;
  432. case 'p':
  433. {
  434.     char fmt[MaxFormatSize]; /* Flawfinder: ignore */
  436.     ConstructFormat(fmt, type, flags, length, precision);
  438.     void* val = va_arg(args, void*);
  439.     convertSize = ConvertPtr(fmt, width, precision, val);
  440. }break;
  442. case '%':
  443.     convertSize = 1;
  444.     break;
  446. default:
  447. {
  448.     HX_ASSERT(!"Unknown format type");
  449.     // Make up something large and hope that it's big enough
  450.     convertSize = 512;
  451. }break;
  452. };
  454.     }
  456.     if (ret)
  457.     {
  458. charCount += (convertSize > width) ? convertSize : width;
  460. pCur = pTmp;
  461.     }
  463.     return ret;
  464. }
  466. static int GuessSize(const char* pFormat, va_list& args)
  467. {
  468.     int ret = 1;
  470.     const char* pCur = pFormat;
  472.     while(*pCur && ret != -1)
  473.     {
  474. switch(*pCur) {
  475. case '%':
  476.     pCur++;
  478.     // Handle format characters
  479.     if (!ParseFormat(pCur, ret, args))
  480. ret = -1;
  481.     break;
  482. default:
  483.     ret++;
  484.     pCur++;
  485.     break;
  486. };
  487.     }
  489.     return ret;
  490. }
  492. // This fudge factor is added to the guess to protect us
  493. // from guessing wrong
  494. static const int FormatFudgeFactor = 128;
  496. void CHXString::Format(const char* pFmt, ...)
  497. {
  498.     va_list args;
  499.     va_start(args, pFmt);
  501.     // Guess the size
  502.     int estimatedSize = GuessSize(pFmt, args);
  504.     va_end(args);
  506.     va_start(args, pFmt);
  508.     if (m_pRep)
  509. m_pRep->Resize(estimatedSize + FormatFudgeFactor);
  510.     else
  511. m_pRep = new CHXStringRep(estimatedSize + FormatFudgeFactor);
  513.     int actualSize = vsnprintf(m_pRep->GetBuffer(), m_pRep->GetBufferSize(),
  514.                                pFmt, args);
  516.     HX_ASSERT(actualSize < estimatedSize);
  518.     m_pRep->SetStringSize(actualSize);
  520.     FreeExtra();
  522.     va_end(args);
  524. }