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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
tchar.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：10k
源码类别：

Windows CE

开发平台：

C/C++

tchar.c：源码内容
  1. /*****************************************************************************
  2.  *
  3.  * This program is free software ; you can redistribute it and/or modify
  4.  * it under the terms of the GNU General Public License as published by
  5.  * the Free Software Foundation; either version 2 of the License, or
  6.  * (at your option) any later version.
  7.  *
  8.  * This program is distributed in the hope that it will be useful,
  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11.  * GNU General Public License for more details.
  12.  *
  13.  * You should have received a copy of the GNU General Public License
  14.  * along with this program; if not, write to the Free Software
  15.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16.  *
  17.  * $Id: tchar.c 271 2005-08-09 08:31:35Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "common.h"
  26. void tcscpy_s(tchar_t* Out,size_t OutLen,const tchar_t* In)
  27. {
  28. if (OutLen>0)
  29. {
  30. size_t n = min(tcslen(In),OutLen-1);
  31. memcpy(Out,In,n*sizeof(tchar_t));
  32. Out[n] = 0;
  33. }
  34. }
  36. void tcsncpy_s(tchar_t* Out,size_t OutLen,const tchar_t* In,size_t n)
  37. {
  38. if (OutLen>0)
  39. {
  40. n = min(min(tcslen(In),n),OutLen-1);
  41. memcpy(Out,In,n*sizeof(tchar_t));
  42. Out[n] = 0;
  43. }
  44. }
  46. void tcscat_s(tchar_t* Out,size_t OutLen,const tchar_t* In)
  47. {
  48. if (OutLen>0)
  49. {
  50. size_t n = tcslen(Out);
  51. tcscpy_s(Out+n,OutLen-n,In);
  52. }
  53. }
  55. tchar_t* tcsdup(const tchar_t* s)
  56. {
  57. size_t n = tcslen(s)+1;
  58. tchar_t* p = (tchar_t*)malloc(n*sizeof(tchar_t));
  59. if (p) tcscpy_s(p,n,s);
  60. return p;
  61. }
  63. void StrToTcs(tchar_t* Out,size_t OutLen,const char* In)
  64. {
  65. StrToTcsEx(Out,OutLen,In,Context()->CodePage);
  66. }
  68. void TcsToStr(char* Out,size_t OutLen,const tchar_t* In)
  69. {
  70. TcsToStrEx(Out,OutLen,In,Context()->CodePage);
  71. }
  73. void BoolToString(tchar_t* Out, size_t OutLen, bool_t Bool)
  74. {
  75. tcscpy_s(Out,OutLen,LangStrDef(PLATFORM_ID,Bool?PLATFORM_YES:PLATFORM_NO));
  76. };
  78. uint32_t StringToFourCC(const tchar_t* In, bool_t Upper)
  79. {
  80. char s[4+1];
  81. tchar_t Up[4+1];
  82. int i;
  84. if (Upper)
  85. {
  86. tcscpy_s(Up,TSIZEOF(Up),In);
  87. tcsupr(Up);
  88. In = Up;
  89. }
  90. TcsToAscii(s,sizeof(s),In);
  92. for (i=0;i<4;++i)
  93. if (!s[i])
  94. for (;i<4;++i)
  95. s[i] = '_';
  97. return FOURCC(s[0],s[1],s[2],s[3]);
  98. }
  100. void FourCCToString(tchar_t* Out, size_t OutLen, uint32_t FourCC)
  101. {
  102. uint32_t s[2];
  103. s[0] = FourCC;
  104. s[1] = 0;
  105. AsciiToTcs(Out,OutLen,(char*)s);
  106. }
  108. uint32_t UpperFourCC(uint32_t FourCC)
  109. {
  110. return (toupper((FourCC >> 0) & 255) << 0) |
  111.    (toupper((FourCC >> 8) & 255) << 8) |
  112.    (toupper((FourCC >> 16) & 255) << 16) |
  113.    (toupper((FourCC >> 24) & 255) << 24);
  114. }
  116. // gcc 2.97 bug...
  117. static const tchar_t mask_d[] = T("%d");
  118. static const tchar_t mask_X[] = T("%X");
  119. static const tchar_t mask_0x08X[] = T("0x%08X");
  121. void FractionToString(tchar_t* Out, size_t OutLen, const fraction* p, bool_t Percent, int Decimal)
  122. {
  123. int a,b,i;
  124. int Num = p->Num;
  125. int Den = p->Den;
  127. if (Percent)
  128. {
  129. while (abs(Num) > MAX_INT/100)
  130. {
  131. Num >>= 1;
  132. Den >>= 1;
  133. }
  134. Num *= 100;
  135. }
  137. if (Den)
  138. {
  139. if (Den<0)
  140. {
  141. Num = -Num;
  142. Den = -Den;
  143. }
  144. for (i=0,b=1;i<Decimal;++i,b*=10);
  145. if (Num>0)
  146. {
  147. // rounding
  148. a = Den/(2*b);
  149. if (Num<MAX_INT-a)
  150. Num += a;
  151. else
  152. Num = MAX_INT;
  153. }
  154. a=Num/Den;
  155. Num -= a*Den;
  156. b=(int)(((int64_t)Num*b)/Den);
  157. }
  158. else
  159. a=b=0;
  161. if (Decimal)
  162. stprintf_s(Out,OutLen,T("%d.%0*d"),a,Decimal,b);
  163. else
  164. stprintf_s(Out,OutLen,mask_d,a);
  166. if (Percent)
  167. tcscat_s(Out,OutLen,T("%"));
  169. }
  171. int StringToInt(const tchar_t* In, bool_t Hex)
  172. {
  173. int v=0;
  174. stscanf(In,Hex ? mask_X:mask_d,&v);
  175. return v;
  176. }
  178. void IntToString(tchar_t* Out, size_t OutLen, int p, bool_t Hex)
  179. {
  180. stprintf_s(Out,OutLen,Hex ? mask_0x08X:mask_d,p);
  181. }
  183. void TickToString(tchar_t* Out, size_t OutLen, tick_t Tick, bool_t MS, bool_t Extended, bool_t Fix)
  184. {
  185. tchar_t Sign[2] = {0};
  186. if (Tick<0) 
  187. {
  188. Sign[0] = '-';
  189. Tick = -Tick;
  190. }
  191. if (!MS)
  192. {
  193. int Hour,Min,Sec;
  194. Hour = Tick / 3600 / TICKSPERSEC;
  195. Tick -= Hour * 3600 * TICKSPERSEC;
  196. Min = Tick / 60 / TICKSPERSEC;
  197. Tick -= Min * 60 * TICKSPERSEC;
  198. Sec = Tick / TICKSPERSEC;
  199. Tick -= Sec * TICKSPERSEC;
  200. if (Hour)
  201. stprintf_s(Out,OutLen,T("%s%d:%02d"),Sign,Hour,Min);
  202. else
  203. stprintf_s(Out,OutLen,Fix?T("%s%02d"):T("%s%d"),Sign,Min);
  204. stcatprintf_s(Out,OutLen,T(":%02d"),Sec);
  205. if (Extended)
  206. stcatprintf_s(Out,OutLen,T(".%03d"),(Tick*1000)/TICKSPERSEC);
  207. }
  208. else
  209. {
  210. int i = Scale(Tick,100000,TICKSPERSEC);
  211. stprintf_s(Out,OutLen,T("%s%d.%02d ms"),Sign,i/100,i%100);
  212. }
  213. }
  215. void stprintf_s(tchar_t* Out,size_t OutLen,const tchar_t* Mask, ...)
  216. {
  217. va_list Arg;
  218. va_start(Arg, Mask);
  219. vstprintf_s(Out,OutLen,Mask,Arg);
  220. va_end(Arg);
  221. }
  223. void stcatprintf_s(tchar_t* Out,size_t OutLen,const tchar_t* Mask, ...)
  224. {
  225. size_t n = tcslen(Out);
  226. va_list Arg;
  227. va_start(Arg, Mask);
  228. vstprintf_s(Out+n,OutLen-n,Mask,Arg);
  229. va_end(Arg);
  230. }
  232. void vstprintf_s(tchar_t* Out,size_t OutLen,const tchar_t* Mask,va_list Arg)
  233. {
  234. int n,vs,Width;
  235. unsigned int v,w,q,w0;
  236. bool_t ZeroFill;
  237. bool_t Unsigned;
  238. bool_t Sign;
  239. bool_t AlignLeft;
  240. const tchar_t *In;
  242. while (OutLen>1 && *Mask)
  243. {
  244. switch (*Mask)
  245. {
  246. case '%':
  247. ++Mask;
  249. if (*Mask == '%')
  250. {
  251. *(Out++) = *(Mask++);
  252. --OutLen;
  253. break;
  254. }
  256. AlignLeft = *Mask=='-';
  257. if (AlignLeft)
  258. ++Mask;
  260. ZeroFill = *Mask=='0';
  261. if (ZeroFill) 
  262. ++Mask;
  264. Width = -1;
  265. if (IsDigit(*Mask))
  266. {
  267. Width = 0;
  268. for (;IsDigit(*Mask);++Mask)
  269. Width = Width*10 + (*Mask-'0');
  270. }
  271. if (*Mask == '*')
  272. {
  273. ++Mask;
  274. Width = va_arg(Arg,int);
  275. }
  277. Unsigned = *Mask=='u';
  278. if (Unsigned)
  279. ++Mask;
  281. switch (*Mask)
  282. {
  283. case 'd':
  284. case 'i':
  285. case 'X':
  286. case 'x':
  287. vs = va_arg(Arg,int);
  289. if (*Mask=='x' || *Mask=='X')
  290. {
  291. Unsigned = 1;
  292. q = 16;
  293. w = 0x10000000;
  294. }
  295. else
  296. {
  297. q = 10;
  298. w = 1000000000;
  299. }
  301. Sign = vs<0 && !Unsigned;
  302. if (Sign)
  303. {
  304. vs=-vs;
  305. --Width;
  306. }
  308. w0 = 1;
  309. for (n=1;n<Width;++n)
  310. w0 *= q;
  312. v = vs;
  313. while (v<w && w>w0)
  314. w/=q;
  316. while (w>0)
  317. {
  318. unsigned int i = v/w;
  319. v-=i*w;
  320. if (OutLen>1 && Sign && (w==1 || ZeroFill || i>0))
  321. {
  322. *(Out++) = '-';
  323. --OutLen;
  324. Sign = 0;
  325. }
  326. if (OutLen>1)
  327. {
  328. if (i==0 && !ZeroFill && w!=1)
  329. i = ' ';
  330. else
  331. {
  332. ZeroFill = 1;
  333. if (i>=10)
  334. {
  335. if (*Mask == 'X')
  336. i += 'A'-10;
  337. else
  338. i += 'a'-10;
  339. }
  340. else
  341. i+='0';
  342. }
  343. *(Out++) = (tchar_t)i;
  344. --OutLen;
  345. }
  346. w/=q;
  347. }
  349. break;
  351. case 'c':
  352. *(Out++) = (tchar_t)va_arg(Arg,int);
  353. --OutLen;
  354. break;
  356. case 's':
  357. In = va_arg(Arg,const tchar_t*);
  358. n = min(tcslen(In),OutLen-1);
  359. Width -= n;
  360. if (!AlignLeft)
  361. while (--Width>=0 && OutLen>1)
  362. {
  363. *Out++ = ' ';
  364. --OutLen;
  365. }
  366. memcpy(Out,In,n*sizeof(tchar_t));
  367. Out += n;
  368. OutLen -= n;
  369. while (--Width>=0 && OutLen>1)
  370. {
  371. *Out++ = ' ';
  372. --OutLen;
  373. }
  374. break;
  375. }
  377. ++Mask;
  378. break;
  380. default:
  381. *(Out++) = *(Mask++);
  382. --OutLen;
  383. break;
  384. }
  385. }
  387. if (OutLen>0)
  388. *Out=0;
  389. }
  391. int stscanf(const tchar_t* In, const tchar_t* Mask, ...)
  392. {
  393. va_list Arg;
  394. int n = 0;
  395. int Sign;
  396. int v;
  397. int Width;
  398. const tchar_t* In0;
  400. va_start(Arg, Mask);
  401. while (In && *In && *Mask)
  402. {
  403. switch (*Mask)
  404. {
  405. case '%':
  406. ++Mask;
  408. Width = -1;
  409. if (IsDigit(*Mask))
  410. {
  411. Width = 0;
  412. for (;IsDigit(*Mask);++Mask)
  413. Width = Width*10 + (*Mask-'0');
  414. }
  416. switch (*Mask)
  417. {
  418. case 'X':
  419. case 'x':
  421. for (;IsSpace(*In);++In);
  422. v = 0;
  423. Sign = *In == '-';
  424. In0 = In;
  425. if (Sign) { ++In; --Width; }
  426. for (;Width!=0 && *In;++In,--Width)
  427. {
  428. int h = Hex(*In);
  429. if (h<0) break;
  430. v=v*16+h;
  431. }
  432. if (Sign) v=-v;
  433. if (In != In0)
  434. {
  435. *va_arg(Arg,int*) = v;
  436. ++n;
  437. }
  438. else
  439. In = NULL;
  440. break;
  442. case 'd':
  443. case 'i':
  445. for (;IsSpace(*In);++In);
  446. v = 0;
  447. Sign = *In == '-';
  448. In0 = In;
  449. if (Sign) ++In;
  450. for (;Width!=0 && IsDigit(*In);++In,--Width)
  451. v=v*10+(*In-'0');
  452. if (Sign) v=-v;
  453. if (In != In0)
  454. {
  455. *va_arg(Arg,int*) = v;
  456. ++n;
  457. }
  458. else
  459. In = NULL;
  460. break;
  462. case 'o':
  464. for (;IsSpace(*In);++In);
  465. v = 0;
  466. Sign = *In == '-';
  467. In0 = In;
  468. if (Sign) ++In;
  469. for (;Width!=0 && *In;++In,--Width)
  470. {
  471. if (*In >= '0' && *In <= '7')
  472. v=v*8+(*In-'0');
  473. else
  474. break;
  475. }
  476. if (Sign) v=-v;
  477. if (In != In0)
  478. {
  479. *va_arg(Arg,int*) = v;
  480. ++n;
  481. }
  482. else
  483. In = NULL;
  484. break;
  485. }
  486. break;
  487. case 9:
  488. case ' ':
  489. for (;IsSpace(*In);++In);
  490. break;
  491. default:
  492. if (*Mask == *In)
  493. ++In;
  494. else
  495. {
  496. In = NULL;
  497. n = -1;
  498. }
  499. }
  500. ++Mask;
  501. }
  503. va_end(Arg);
  504. return n;
  505. }
  507. void GUIDToString(tchar_t* Out, size_t OutLen, const guid* p)
  508. {
  509. stprintf_s(Out,OutLen,T("%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x"),
  510. (int)p->v1,p->v2,p->v3,p->v4[0],p->v4[1],p->v4[2],p->v4[3],
  511. p->v4[4],p->v4[5],p->v4[6],p->v4[7]);
  512. }
  514. bool_t StringToGUID(const tchar_t* In, guid* p)
  515. {
  516. int i,v[10];
  517. if (stscanf(In,T("%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x"),
  518. &p->v1,v+0,v+1,v+2,v+3,v+4,v+5,v+6,v+7,v+8,v+9) < 11)
  519. {
  520. memset(p,0,sizeof(guid));
  521. return 0;
  522. }
  523. p->v2 = (uint16_t)v[0];
  524. p->v3 = (uint16_t)v[1];
  525. for (i=0;i<8;++i)
  526. p->v4[i] = (uint8_t)v[2+i];
  527. return 1;
  528. }
  530. bool_t IsSpace(int ch) { return ch==' ' || ch==9; }
  531. bool_t IsAlpha(int ch) { return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'); }
  532. bool_t IsDigit(int ch) { return ch>='0' && ch<='9'; }
  534. int Hex(int ch) 
  535. {
  536. if (IsDigit(ch))
  537. return ch-'0';
  538. if (ch >= 'a' && ch <= 'f')
  539. return ch-'a'+10;
  540. if (ch >= 'A' && ch <= 'F')
  541. return ch-'A'+10;
  542. return -1;
  543. }
  545. void tcsuprto(tchar_t* p, tchar_t Delimiter)
  546. {
  547. for (;*p && *p!=Delimiter;++p)
  548. *p = (char)toupper(*p);
  549. }
  551. void tcsupr(tchar_t* p) 
  552. {
  553. for (;*p;++p)
  554. *p = (char)toupper(*p);
  555. }