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

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

Windows CE

开发平台：

C/C++

tagz.cpp：源码内容
  1. #include <string.h>
  2. #include <stdio.h>
  3. #include <ctype.h>
  4. #include <stdlib.h>
  5. #include "tagz.h"
  7. #ifdef TAGZ_UNICODE
  9. #define _TX(X)      L##X
  10. #define t_strdup    wcsdup
  11. #define t_strlen    wcslen
  12. #define t_strnicmp  wcsnicmp
  13. #define t_atoi(x)   wcstol(x,0,10)
  14. #define t_stricmp   wcsicmp
  15. #define t_strstr    wcsstr
  16. #define sprintf     swprintf
  18. #else
  20. #define _TX(X)      X
  21. #define t_strdup    strdup
  22. #define t_strlen    strlen
  23. #define t_strnicmp  strnicmp
  24. #define t_atoi      atoi
  25. #define t_stricmp   stricmp
  26. #define t_strstr    strstr
  28. #endif
  30. #define TABSIZE(x) (sizeof(x)/sizeof(x[0]))
  33. class T_String
  34. {
  35. private:
  36. T_CHAR * data;
  37. UINT size,used;
  38. public:
  39. T_String() {data=0;size=0;used=0;}
  40. void AddChar(T_CHAR c)
  41. {
  42. if (!data)
  43. {
  44. data=(T_CHAR*)malloc((size=512)*sizeof(T_CHAR));
  45. used=0;
  46. }
  47. else if (size==used)
  48. {
  49. size<<=1;
  50. data=(T_CHAR*)realloc((char*)data,size*sizeof(T_CHAR));
  51. }
  52. if (data) data[used++]=c;
  53. }
  54. void AddInt(int i)
  55. {
  56. T_CHAR foo[16];
  57. sprintf(foo,_TX("%i"),i);
  58. AddString(foo);
  59. }
  60. void AddString(const T_CHAR * z)
  61. {
  62. while(*z) {AddChar(*z);z++;}
  63. }
  64. void AddString(T_String & s)
  65. {
  66. AddString(s.Peek());
  67. }
  68. ~T_String()
  69. {
  70. if (data) free(data);
  71. }
  72. T_CHAR * GetBuf()
  73. {
  74. if (!data) return ::t_strdup(_TX(""));
  75. T_CHAR * r=(T_CHAR*)realloc(data,(used+1)*sizeof(T_CHAR));
  76. r[used]=0;
  77. data=0;
  78. return r;
  79. }
  80. T_CHAR operator[](UINT i)
  81. {
  82. if (!data || i>=used) return 0;
  83. else return data[i];
  84. }
  85. UINT Len() {return data ? used : 0;}
  86. void Reset()
  87. {
  88. if (data) {free(data);data=0;}
  89. }
  90. const T_CHAR * Peek()
  91. {
  92. AddChar(0);
  93. used--;
  94. return data;
  95. }
  96. T_CHAR * strdup()
  97. {
  98. return ::t_strdup(Peek());
  99. }
  100. };
  105. static int separator(T_CHAR x)
  106. {
  107. if (!x || x==' ') return 1;
  108. if (x==''' || x=='_') return 0;
  109. #ifdef TAGZ_UNICODE
  110. return !iswalnum(x);
  111. #else
  112. return !isalnum(x);
  113. #endif
  114. }
  116. static int sepcmp(T_CHAR* src,T_CHAR* val)
  117. {
  118. UINT l=t_strlen(val);
  119. return !t_strnicmp(src,val,l) && separator(src[l]);
  120. }
  122. static char roman_num[]=
  123. {
  124. 'I','V','X','L','C','D','M'
  125. };
  128. static int is_roman(T_CHAR * ptr)/* could be more smart i think */
  129. {
  130. if (ptr[0]==']' && ptr[1]=='[' && separator(ptr[2])) return 1;
  131. while(!separator(*ptr))
  132. {
  133. UINT n;
  134. bool found=0;
  135. for(n=0;n<TABSIZE(roman_num);n++)
  136. {
  137. if (*ptr==roman_num[n]) {found=1;break;}
  138. }
  139. if (!found) return 0;
  140. ptr++;
  141. }
  142. return 1;
  143. }
  145. static int need_full(T_CHAR* ptr)
  146. {
  147. if (is_roman(ptr)) return 1;
  148. if (sepcmp(ptr,_TX("RPG"))) return 1;
  149. while(!separator(*ptr))
  150. {
  151. if (*ptr<'0' || *ptr>'9') return 0;
  152. ptr++;
  153. }
  154. return 1;
  155. }
  157. typedef bool (*TEXTFUNC)(UINT n_src,T_CHAR **src,UINT*,T_String &out);
  159. #define MAKEFUNC(X) static bool X(UINT n_src,T_CHAR ** src,UINT *found_src,T_String &out)
  162. MAKEFUNC(If)
  163. {
  164. if (n_src!=3) return false;
  166. out.AddString(src[found_src[0] ? 1 : 2]);
  167. return true;
  168. }
  170. MAKEFUNC(If2)
  171. {
  172. if (n_src!=2) return false;
  174. out.AddString(src[found_src[0] ? 0 : 1]);
  175. return true;
  176. }
  179. MAKEFUNC(Iflonger)
  180. {
  181. if (n_src!=4) return false;
  183. out.AddString(src[(int)t_strlen(src[0])>t_atoi(src[1]) ? 2 : 3]);
  184. return true;
  185. }
  187. MAKEFUNC(Ifgreater)
  188. {
  189. if (n_src!=4) return false;
  191. out.AddString(src[t_atoi(src[0])>t_atoi(src[1]) ? 2 : 3]);
  192. return true;
  193. }
  195. MAKEFUNC(Upper)
  196. {
  197. if (n_src!=1) return false;
  199. T_CHAR * s=src[0];
  201. while(*s)
  202. out.AddChar(toupper(*(s++)));
  204. return true;
  205. }
  207. MAKEFUNC(Lower)
  208. {
  209. if (n_src!=1) return false;
  211. T_CHAR * s=src[0];
  213. while(*s)
  214. out.AddChar(tolower(*(s++)));
  216. return true;
  217. }
  219. MAKEFUNC(Pad)
  220. {
  221. if (n_src<2 || n_src>3) return false;
  223. T_CHAR *fill=_TX(" ");
  224. if (n_src==3 && src[2][0])
  225. fill = src[2];
  227. int num = t_atoi(src[1]);
  228. T_CHAR *p = src[0];
  230. while (*p) { out.AddChar(*(p++)); num--; }
  232. UINT fl = t_strlen(fill);
  233. while (num>0)
  234. out.AddChar(fill[(--num)%fl]);
  236. return true;
  237. }
  239. MAKEFUNC(Cut)
  240. {
  241. if (n_src!=2) return false;
  243. UINT num = t_atoi(src[1]);
  244. T_CHAR *p = src[0];
  246. while (*p && num>0) {out.AddChar(*(p++));num--;}
  248. return true;
  249. }
  251. MAKEFUNC(PadCut)
  252. {
  253. if (n_src<2 || n_src>3) return false;
  255. T_CHAR *fill = _TX(" ");
  256. if (n_src==3 && src[2][0])
  257. fill = src[2];
  259. int num = t_atoi(src[1]);
  260. T_CHAR *p = src[0];
  262. while(*p && num>0) {out.AddChar(*(p++));num--;}
  264. UINT fl=t_strlen(fill);
  265. while (num>0)
  266. out.AddChar(fill[(--num)%fl]);
  268. return true;
  269. }
  271. /* abbr(string) */
  272. /* abbr(string,len) */
  273. MAKEFUNC(Abbr)
  274. {
  275. if (n_src==0 || n_src>2) return false;
  278. if (n_src==2 && (int)t_strlen(src[0])<t_atoi(src[1]))
  279. {
  280. out.AddString(src[0]);
  281. return true;
  282. }
  284. T_CHAR * meta=src[0];
  285. bool w=0, r=0;
  287. while(*meta)
  288. {
  289. bool an=!separator(*meta) || *meta==']' || *meta=='[';
  291. if (w && !an)
  292. w=0;
  293. else if (!w && an)
  294. {
  295. w=1;
  296. r=need_full(meta)?1:0;
  297. out.AddChar(*meta);
  298. }
  299. else if (w && r)
  300. out.AddChar(*meta);
  301. meta++;
  302. }
  304. return true;
  305. }
  309. MAKEFUNC(Caps)
  310. {
  311. if (n_src!=1) return false;
  313. T_CHAR* sp=src[0];
  314. int sep = 1;
  316. while(*sp)
  317. {
  318. T_CHAR c=*(sp++);
  319. int s = separator(c);
  320. if (!s && sep)
  321. c=toupper(c);
  322. else if (!sep) c=tolower(c);
  323. sep=s;
  324. out.AddChar(c);
  325. }
  327. return true;
  328. }
  330. MAKEFUNC(Caps2)
  331. {
  332. if (n_src!=1) return false;
  334. T_CHAR* sp=src[0];
  335. int sep=1;
  337. while(*sp)
  338. {
  339. T_CHAR c=*(sp++);
  340. int s = separator(c);
  341. if (!s && sep)
  342. c=toupper(c);
  343. sep=s;
  344. out.AddChar(c);
  345. }
  347. return true;
  348. }
  350. MAKEFUNC(Longest)
  351. {
  352. T_CHAR *ptr=0;
  353. UINT n, m=0;
  355. for(n=0;n<n_src;n++)
  356. {
  357. UINT l=t_strlen(src[n]);
  358. if (l>m) {m=l;ptr=src[n];}
  359. }
  361. if (ptr) out.AddString(ptr);
  362. return true;
  363. }
  365. MAKEFUNC(Shortest)
  366. {
  367. T_CHAR * ptr=0;
  368. UINT n,m=(UINT)(-1);
  370. for(n=0;n<n_src;n++)
  371. {
  372. UINT l=t_strlen(src[n]);
  373. if (l<m) {m=l;ptr=src[n];}
  374. }
  376. if (ptr) out.AddString(ptr);
  377. return true;
  378. }
  380. MAKEFUNC(Num)
  381. {
  382. if (n_src!=2) return false;
  384. T_CHAR tmp[16];
  385. T_CHAR tmp1[16];
  386. sprintf(tmp1,_TX("%%0%uu"),t_atoi(src[1]));
  387. sprintf(tmp,tmp1,t_atoi(src[0]));
  388. out.AddString(tmp);
  390. return true;
  391. }
  393. MAKEFUNC(Hex)
  394. {
  395. if (n_src!=2) return false;
  397. T_CHAR tmp[16];
  398. T_CHAR tmp1[16];
  399. sprintf(tmp1,_TX("%%0%ux"),t_atoi(src[1]));
  400. sprintf(tmp,tmp1,t_atoi(src[0]));
  401. out.AddString(tmp);
  403. return true;
  404. }
  406. MAKEFUNC(StrChr)
  407. {
  408. if (n_src!=2) return false;
  410. T_CHAR * p=src[0];
  411. T_CHAR s=src[1][0];
  413. while (*p && *p!=s) p++;
  414. if (*p==s)
  415. out.AddInt(1+p-src[0]);
  416. else out.AddChar('0');
  418. return true;
  419. }
  421. MAKEFUNC(StrRChr)
  422. {
  423. if (n_src!=2) return false;
  425. T_CHAR * p=src[0],*p1=0;
  426. T_CHAR s=src[1][0];
  428. while(*p)
  429. {
  430. if (*p==s) p1=p;
  431. p++;
  432. }
  434. if (p1)
  435. out.AddInt(1+p1-src[0]);
  436. else out.AddChar('0');
  438. return true;
  439. }
  441. MAKEFUNC(StrStr)
  442. {
  443. if (n_src!=2) return false;
  445. T_CHAR * p = t_strstr(src[0],src[1]);
  447. if (p)
  448. out.AddInt(1+p-src[0]);
  449. else out.AddChar('0');
  451. return true;
  452. }
  454. /* substr(string, index) */
  455. /* substr(string, index, length) */
  456. MAKEFUNC(SubStr)
  457. {
  458. if (n_src<2 || n_src>3) return false;
  460. int n1 = t_atoi(src[1]), n2;
  462. if (n_src == 3)
  463. n2 = t_atoi(src[2]);
  464. else n2 = n1;
  466. if (n1 < 1) n1=1;
  467. if (n2 >= n1)
  468. {
  469. n1--;
  470. n2--;
  471. while(n1<=n2 && src[0][n1])
  472. out.AddChar(src[0][n1++]);
  473. }
  475. return true;
  476. }
  478. MAKEFUNC(Len)
  479. {
  480. if (n_src!=1) return false;
  482. out.AddInt(t_strlen(src[0]));
  483. return true;
  484. }
  486. MAKEFUNC(Add)
  487. {
  488. UINT n;
  489. int s=0;
  491. for (n=0;n<n_src;n++)
  492. s+=t_atoi(src[n]);
  494. out.AddInt(s);
  496. return true;
  497. }
  499. MAKEFUNC(Sub)
  500. {
  501. if (n_src==0) return false;
  503. UINT n;
  504. int s=t_atoi(src[0]);
  506. for (n=1;n<n_src;n++)
  507. s-=t_atoi(src[n]);
  509. out.AddInt(s);
  511. return true;
  512. }
  514. MAKEFUNC(Mul)
  515. {
  516. UINT n;
  517. int s=1;
  519. for(n=0;n<n_src;n++)
  520. s*=t_atoi(src[n]);
  522. out.AddInt(s);
  524. return true;
  525. }
  527. MAKEFUNC(Div)
  528. {
  529. if (n_src==0) return false;
  531. UINT n;
  532. int s=t_atoi(src[0]);
  534. for(n=1;n<n_src;n++)
  535. {
  536. int t=t_atoi(src[n]);
  537. if (t) s/=t;
  538. else t=0;
  539. }
  541. out.AddInt(s);
  543. return true;
  544. }
  546. MAKEFUNC(Mod)
  547. {
  548. if (n_src==0) return false;
  550. UINT n;
  551. int s=t_atoi(src[0]);
  553. for(n=1;n<n_src;n++)
  554. {
  555. int t=t_atoi(src[n]);
  556. if (t) s%=t;
  557. else t=0;
  558. }
  560. out.AddInt(s);
  562. return true;
  563. }
  565. MAKEFUNC(Max)
  566. {
  567. if (!n_src) return false;
  569. int m = t_atoi(src[0]);
  570. UINT n;
  572. for (n=1; n<n_src; n++)
  573. {
  574. int t = t_atoi(src[n]);
  575. if (t > m) m = t;
  576. }
  577. out.AddInt(m);
  579. return true;
  580. }
  582. MAKEFUNC(Min)
  583. {
  584. if (!n_src) return false;
  586. int m=t_atoi(src[0]);
  587. UINT n;
  589. for(n=1;n<n_src;n++)
  590. {
  591. int t=t_atoi(src[n]);
  592. if (t<m) m=t;
  593. }
  594. out.AddInt(m);
  596. return true;
  597. }
  599. /* replace(string, what_to_replace, replacement) */
  600. MAKEFUNC(Replace)
  601. {
  602. if (n_src!=3) return false;
  603. T_CHAR *p = src[0];
  605. while (*p)
  606. {
  607. UINT n=0;
  609. while (src[1][n] && p[n]==src[1][n]) n++;
  611. if (!src[1][n])
  612. {
  613. out.AddString(src[2]);
  614. p += n;
  615. }
  616. else out.AddChar(*p++);
  617. }
  619. return true;
  620. }
  622. struct
  623. {
  624. TEXTFUNC func;
  625. const T_CHAR * name;
  626. }
  627. FUNCS[] =
  628. {
  629. If,_TX("if"),
  630. If2,_TX("if2"),
  631. Upper,_TX("upper"),
  632. Lower,_TX("lower"),
  633. Pad,_TX("pad"),
  634. Cut,_TX("cut"),
  635. PadCut,_TX("padcut"),
  636. Abbr,_TX("abbr"),
  637. Caps,_TX("caps"),
  638. Caps2,_TX("caps2"),
  639. Longest,_TX("longest"),
  640. Shortest,_TX("shortest"),
  641. Iflonger,_TX("iflonger"),
  642. Ifgreater,_TX("ifgreater"),
  643. Num,_TX("num"),Num,_TX("dec"),
  644. Hex,_TX("hex"),
  645. StrChr,_TX("strchr"),
  646. StrChr,_TX("strlchr"),
  647. StrRChr,_TX("strrchr"),
  648. StrStr,_TX("strstr"),
  649. SubStr,_TX("substr"),
  650. Len,_TX("len"),
  651. Add,_TX("add"),
  652. Sub,_TX("sub"),
  653. Mul,_TX("mul"),
  654. Div,_TX("div"),
  655. Mod,_TX("mod"),
  656. Min,_TX("min"),
  657. Max,_TX("max"),
  658. Replace,_TX("replace"),
  659. };
  662. class FMT
  663. {
  664. private:
  665. T_String str;
  666. T_CHAR * spec;
  667. TAGFUNC f;
  668. TAGFREEFUNC ff;
  669. void * fp;
  670. T_CHAR * org_spec;
  671. int found;
  673. void Error(T_CHAR *e=0)
  674. {
  675. str.Reset();
  676. str.AddString(e ? e : _TX("[SYNTAX ERROR IN FORMATTING STRING]"));
  677. found++;  /* force displaying */
  678. }
  680. T_CHAR * _FMT(T_CHAR * s,UINT *f=0)
  681. {
  682. FMT fmt(this,s);
  683. T_CHAR * c=(T_CHAR*)fmt;
  684. if (f) *f=fmt.found;
  685. found+=fmt.found;
  686. return c;
  687. }
  689. static bool skipshit(T_CHAR** _p,T_CHAR *bl)
  690. {
  691. T_CHAR * p=*_p;
  692. int bc1=0,bc2=0;
  693. while(*p)
  694. {
  695. if (!bc1 && !bc2 && bl)
  696. {
  697. T_CHAR *z=bl;
  698. while(*z)
  699. {
  700. if (*z==*p) break;
  701. z++;
  702. }
  703. if (*z) break;
  704. }
  705. if (*p==''')
  706. {
  707. p++;
  708. while(*p && *p!=''') p++;
  709. if (!*p) return 0;
  710. }
  711. else if (*p=='(') bc1++;
  712. else if (*p==')')
  713. {
  714. if (--bc1<0) return 0;
  715. }
  716. else if (*p=='[') bc2++;
  717. else if (*p==']')
  718. {
  719. if (--bc2<0) return 0;
  720. }
  721. p++;
  722. }
  723. *_p=p;
  724. return *p && !bc1 && !bc2;
  725. }
  727. void run()
  728. {
  729. if (!spec) {Error();return;}
  730. while(*spec)
  731. {
  732. if (*spec=='%')
  733. {
  734. spec++;
  735. if (*spec=='%') {str.AddChar('%');spec++;continue;}
  736. T_CHAR* s1=spec+1;
  737. while(*s1 && *s1!='%') s1++;
  738. if (!*s1) {Error();break;}
  739. *s1=0;
  740. T_CHAR * tag=f(spec,fp);
  741. *s1='%';
  742. /*if (!tag) tag=tag_unknown; */
  743. if (tag && tag[0])
  744. {
  745. found++;
  746. str.AddString(tag);
  747. }
  748. else
  749. {
  750. str.AddString(_TX("?"));
  751. }
  752. if (tag && ff) ff(tag,fp);
  753. spec=s1+1;
  754. }
  755. else if (*spec=='$')
  756. {
  757. spec++;
  758. if (*spec=='$') {str.AddChar('$');spec++;continue;}
  759. T_CHAR * s1=spec+1;
  760. while(*s1 && *s1!='(') s1++;
  761. if (!*s1) {Error();break;}
  762. T_CHAR * s2=s1+1;
  763. if (!skipshit(&s2,_TX(")"))) {Error();break;}
  764. if (!*s2) {Error();break;};
  765. T_CHAR * p=s1+1;
  766. T_CHAR* temp[64];
  767. UINT temp_f[64];
  768. UINT nt=0;
  769. T_CHAR * p1=s1+1;
  770. while(p<=s2 && nt<64)
  771. {
  772. if (!skipshit(&p,_TX(",)"))) {Error();return;}
  773. if (p>s2 || (*p!=',' && *p!=')')) {Error(_TX("internal error"));return;}
  774. T_CHAR bk=*p;
  775. *p=0;
  776. temp[nt]=_FMT(p1,&temp_f[nt]);
  777. nt++;
  778. *p=bk;;
  779. p1=p+1;
  780. p++;
  781. }
  782. *s1=0;
  783. UINT n;
  785. for (n=0; n<TABSIZE(FUNCS); n++)
  786. if (!t_stricmp(spec, FUNCS[n].name))
  787. break;
  789. *s1='(';
  791. if (n != TABSIZE(FUNCS))
  792. {
  793. if (!FUNCS[n].func(nt, temp, temp_f, str))
  794. {
  795. Error(_TX("[INVALID $"));
  796. str.AddString(FUNCS[n].name);
  797. str.AddString(_TX(" SYNTAX]"));
  798. return;
  799. }
  800. }
  801. else
  802. {
  803. Error(_TX("[UNKNOWN FUNCTION]"));
  804. return;
  805. }
  807. for(n=0;n<nt;n++) free(temp[n]);
  808. spec=s2+1;
  809. }
  810. else if (*spec==''')
  811. {
  812. spec++;
  813. if (*spec==''') {str.AddChar(''');spec++;continue;}
  814. T_CHAR * s1=spec+1;
  815. while(*s1 && *s1!=''') s1++;
  816. if (!*s1) {Error();break;}
  817. *s1=0;
  818. str.AddString(spec);
  819. *s1=''';
  820. spec=s1+1;
  821. }
  822. else if (*spec=='[')
  823. {
  824. spec++;
  825. T_CHAR * s1=spec;
  826. UINT bc=0;
  827. if (!skipshit(&s1,_TX("]"))) {Error();break;}
  828. T_CHAR bk=*s1;
  829. *s1=0;
  830. FMT fmt(this,spec);
  831. fmt.run();
  832. if (fmt.found)
  833. {
  834. str.AddString(fmt.str);
  835. found+=fmt.found;
  836. }
  837. *s1=bk;
  838. spec=s1+1;
  839. }
  840. else if (*spec == ']') {Error();break;}
  841. else
  842. {
  843. str.AddChar(*spec);
  844. spec++;
  845. }
  846. }
  847. }
  849. FMT(FMT* base,T_CHAR * _spec)
  850. {
  851. found=0;
  852. org_spec=0;
  853. f=base->f;
  854. ff=base->ff;
  855. fp=base->fp;
  856. spec=_spec;
  857. }
  858. public:
  859. FMT(const T_CHAR * p_spec,TAGFUNC _f,TAGFREEFUNC _ff,void * _fp)
  860. {
  861. found=0;
  862. org_spec=spec=t_strdup(p_spec);
  863. f=_f;
  864. ff=_ff;
  865. fp=_fp;
  866. }
  867. operator T_CHAR*()
  868. {
  869. run();
  870. return str.GetBuf();
  871. }
  872. ~FMT()
  873. {
  874. if (org_spec) free(org_spec);
  875. }
  876. };
  878. extern "C"
  879. {
  881. UINT tagz_format(const T_CHAR * spec,TAGFUNC f,TAGFREEFUNC ff,void *fp,T_CHAR* out,UINT max)
  882. {
  883. T_CHAR * zz=tagz_format_r(spec,f,ff,fp);
  884. UINT r=0;
  885. while(r<max-1 && zz[r])
  886. {
  887. out[r]=zz[r];
  888. r++;
  889. }
  890. out[r]=0;
  891. free(zz);
  892. return r;
  893. }
  895. T_CHAR * tagz_format_r(const T_CHAR* spec,TAGFUNC f,TAGFREEFUNC ff,void * fp)
  896. {
  897. return FMT(spec,f,ff,fp);
  898. }
  900. const char tagz_manual[]="Syntax reference: n"
  901. "n"
  902. "* %tagname% - inserts field named <tagname>, eg. "%artist%"n"
  903. "* $abbr(x) - inserts abbreviation of x, eg. "$abbr(%album%)" - will convert album name of "Final Fantasy VI" to "FFVI"n"
  904. "* $abbr(x,y) - inserts abbreviation of x if x is longer than y characters; otherwise inserts full value of x, eg. "$abbr(%album%,10)"n"
  905. "* $lower(x), $upper(x) - converts x to in lower/uppercase, eg. "$upper(%title%)"n"
  906. "* $num(x,y) - displays x number and pads with zeros up to y characters (useful for track numbers), eg. $num(%tracknumber%,2)n"
  907. "* $caps(x) - converts first letter in every word of x to uppercase, and all other letters to lowercase, eg. "blah BLAH" -> "Blah Blah"n"
  908. "* $caps2(x) - similar to $caps, but leaves uppercase letters as they are, eg. "blah BLAH" -> "Blah BLAH"n"
  909. "* $if(A,B,C) - if A contains at least one valid tag, displays B, otherwise displays C; eg. "$if(%artist%,%artist%,unknown artist)" will display artist name if present; otherwise will display "unknown artist"; note that "$if(A,A,)" is equivalent to "[A]" (see below)n"
  910. "* $if2(A,B) - equals to $if(A,A,B)n"
  911. "* $longest(A,B,C,....) - compares lengths of output strings produced by A,B,C... and displays the longest one, eg. "$longest(%title%,%comment%)" will display either title if it's longer than comment; otherwise it will display commentn"
  912. "* $pad(x,y) - pads x with spaces up to y charactersn"
  913. "* $cut(x,y) - truncates x to y charactersn"
  914. "* $padcut(x,y) - pads x to y characters and truncates to y if longern"
  915. "* [ .... ] - displays contents of brackets only if at least one of fields referenced inside has been found, eg. "%artist% - [%album% / ]%title%" will hide [] block if album field is not presentn"
  916. "* ' (single quotation mark) - outputs raw text without parsing, eg, 'blah$blah%blah[][]' will output the contained string and ignore all reserved characters (%,$,[,]) in it; you can use this feature to insert square brackets for an example.n"
  917. "n"
  918. "eg. "[%artist% - ][$abbr(%album%,10)[ %tracknumber%] / ]%title%[ %streamtitle%]"n";
  921. }