StringTools.hx 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611
  1. /*
  2. * Copyright (C)2005-2019 Haxe Foundation
  3. *
  4. * Permission is hereby granted, free of charge, to any person obtaining a
  5. * copy of this software and associated documentation files (the "Software"),
  6. * to deal in the Software without restriction, including without limitation
  7. * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  8. * and/or sell copies of the Software, and to permit persons to whom the
  9. * Software is furnished to do so, subject to the following conditions:
  10. *
  11. * The above copyright notice and this permission notice shall be included in
  12. * all copies or substantial portions of the Software.
  13. *
  14. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15. * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16. * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17. * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18. * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  19. * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  20. * DEALINGS IN THE SOFTWARE.
  21. */
  22. import haxe.iterators.StringIterator;
  23. import haxe.iterators.StringKeyValueIterator;
  24. #if cpp
  25. using cpp.NativeString;
  26. #end
  27. /**
  28. This class provides advanced methods on Strings. It is ideally used with
  29. `using StringTools` and then acts as an [extension](https://haxe.org/manual/lf-static-extension.html)
  30. to the `String` class.
  31. If the first argument to any of the methods is null, the result is
  32. unspecified.
  33. **/
  34. class StringTools {
  35. /**
  36. Encode an URL by using the standard format.
  37. **/
  38. #if (!java && !cpp && !lua && !eval) inline #end public static function urlEncode(s:String):String {
  39. #if flash
  40. return untyped __global__["encodeURIComponent"](s);
  41. #elseif neko
  42. return untyped new String(_urlEncode(s.__s));
  43. #elseif js
  44. return untyped encodeURIComponent(s);
  45. #elseif cpp
  46. return untyped s.__URLEncode();
  47. #elseif java
  48. return postProcessUrlEncode(java.net.URLEncoder.encode(s, "UTF-8"));
  49. #elseif cs
  50. return untyped cs.system.Uri.EscapeDataString(s);
  51. #elseif python
  52. return python.lib.urllib.Parse.quote(s, "");
  53. #elseif hl
  54. var len = 0;
  55. var b = @:privateAccess s.bytes.urlEncode(len);
  56. return @:privateAccess String.__alloc__(b, len);
  57. #elseif lua
  58. s = lua.NativeStringTools.gsub(s, "\n", "\r\n");
  59. s = lua.NativeStringTools.gsub(s, "([^%w %-%_%.%~])", function(c) {
  60. return lua.NativeStringTools.format("%%%02X", lua.NativeStringTools.byte(c) + '');
  61. });
  62. s = lua.NativeStringTools.gsub(s, " ", "+");
  63. return s;
  64. #else
  65. return null;
  66. #end
  67. }
  68. #if java
  69. private static function postProcessUrlEncode(s:String):String {
  70. var ret = new StringBuf();
  71. var i = 0, len = s.length;
  72. while (i < len) {
  73. switch (_charAt(s, i++)) {
  74. case '+'.code:
  75. ret.add('%20');
  76. case '%'.code if (i <= len - 2):
  77. var c1 = _charAt(s, i++), c2 = _charAt(s, i++);
  78. switch [c1, c2] {
  79. case ['2'.code, '1'.code]:
  80. ret.addChar('!'.code);
  81. case ['2'.code, '7'.code]:
  82. ret.addChar('\''.code);
  83. case ['2'.code, '8'.code]:
  84. ret.addChar('('.code);
  85. case ['2'.code, '9'.code]:
  86. ret.addChar(')'.code);
  87. case ['7'.code, 'E'.code] | ['7'.code, 'e'.code]:
  88. ret.addChar('~'.code);
  89. case _:
  90. ret.addChar('%'.code);
  91. ret.addChar(cast c1);
  92. ret.addChar(cast c2);
  93. }
  94. case var chr:
  95. ret.addChar(cast chr);
  96. }
  97. }
  98. return ret.toString();
  99. }
  100. #end
  101. /**
  102. Decode an URL using the standard format.
  103. **/
  104. #if (!java && !cpp && !lua && !eval) inline #end public static function urlDecode(s:String):String {
  105. #if flash
  106. return untyped __global__["decodeURIComponent"](s.split("+").join(" "));
  107. #elseif neko
  108. return untyped new String(_urlDecode(s.__s));
  109. #elseif js
  110. return untyped decodeURIComponent(s.split("+").join(" "));
  111. #elseif cpp
  112. return untyped s.__URLDecode();
  113. #elseif java
  114. try
  115. return java.net.URLDecoder.decode(s, "UTF-8")
  116. catch (e:Dynamic)
  117. throw e;
  118. #elseif cs
  119. return untyped cs.system.Uri.UnescapeDataString(s);
  120. #elseif python
  121. return python.lib.urllib.Parse.unquote(s);
  122. #elseif hl
  123. var len = 0;
  124. var b = @:privateAccess s.bytes.urlDecode(len);
  125. return @:privateAccess String.__alloc__(b, len);
  126. #elseif lua
  127. s = lua.NativeStringTools.gsub(s, "+", " ");
  128. s = lua.NativeStringTools.gsub(s, "%%(%x%x)", function(h) {
  129. return lua.NativeStringTools.char(lua.Lua.tonumber(h, 16));
  130. });
  131. s = lua.NativeStringTools.gsub(s, "\r\n", "\n");
  132. return s;
  133. #else
  134. return null;
  135. #end
  136. }
  137. /**
  138. Escapes HTML special characters of the string `s`.
  139. The following replacements are made:
  140. - `&` becomes `&amp`;
  141. - `<` becomes `&lt`;
  142. - `>` becomes `&gt`;
  143. If `quotes` is true, the following characters are also replaced:
  144. - `"` becomes `&quot`;
  145. - `'` becomes `&#039`;
  146. **/
  147. public static function htmlEscape(s:String, ?quotes:Bool):String {
  148. var buf = new StringBuf();
  149. for (code in #if neko iterator(s) #else new haxe.iterators.StringIteratorUnicode(s) #end) {
  150. switch (code) {
  151. case '&'.code:
  152. buf.add("&amp;");
  153. case '<'.code:
  154. buf.add("&lt;");
  155. case '>'.code:
  156. buf.add("&gt;");
  157. case '"'.code if (quotes):
  158. buf.add("&quot;");
  159. case '\''.code if (quotes):
  160. buf.add("&#039;");
  161. case _:
  162. buf.addChar(code);
  163. }
  164. }
  165. return buf.toString();
  166. }
  167. /**
  168. Unescapes HTML special characters of the string `s`.
  169. This is the inverse operation to htmlEscape, i.e. the following always
  170. holds: `htmlUnescape(htmlEscape(s)) == s`
  171. The replacements follow:
  172. - `&amp;` becomes `&`
  173. - `&lt;` becomes `<`
  174. - `&gt;` becomes `>`
  175. - `&quot;` becomes `"`
  176. - `&#039;` becomes `'`
  177. **/
  178. public static function htmlUnescape(s:String):String {
  179. return s.split("&gt;")
  180. .join(">")
  181. .split("&lt;")
  182. .join("<")
  183. .split("&quot;")
  184. .join('"')
  185. .split("&#039;")
  186. .join("'")
  187. .split("&amp;")
  188. .join("&");
  189. }
  190. /**
  191. Returns `true` if `s` contains `value` and `false` otherwise.
  192. When `value` is `null`, the result is unspecified.
  193. **/
  194. public static inline function contains(s:String, value:String):Bool {
  195. return s.indexOf(value) != -1;
  196. }
  197. /**
  198. Tells if the string `s` starts with the string `start`.
  199. If `start` is `null`, the result is unspecified.
  200. If `start` is the empty String `""`, the result is true.
  201. **/
  202. public static #if (cs || java || python) inline #end function startsWith(s:String, start:String):Bool {
  203. #if java
  204. return (cast s : java.NativeString).startsWith(start);
  205. #elseif cs
  206. return untyped s.StartsWith(start);
  207. #elseif cpp
  208. if (s.length < start.length)
  209. return false;
  210. var p0 = s.c_str();
  211. var p1 = start.c_str();
  212. for (i in 0...start.length)
  213. if (p0.at(i) != p1.at(i))
  214. return false;
  215. return true;
  216. #elseif hl
  217. return @:privateAccess (s.length >= start.length && s.bytes.compare(0, start.bytes, 0, start.length << 1) == 0);
  218. #elseif python
  219. return python.NativeStringTools.startswith(s, start);
  220. #else
  221. return (s.length >= start.length && s.lastIndexOf(start, 0) == 0);
  222. #end
  223. }
  224. /**
  225. Tells if the string `s` ends with the string `end`.
  226. If `end` is `null`, the result is unspecified.
  227. If `end` is the empty String `""`, the result is true.
  228. **/
  229. public static #if (cs || java || python) inline #end function endsWith(s:String, end:String):Bool {
  230. #if java
  231. return (cast s : java.NativeString).endsWith(end);
  232. #elseif cs
  233. return untyped s.EndsWith(end);
  234. #elseif cpp
  235. if (s.length < end.length)
  236. return false;
  237. var p0 = s.c_str().add(s.length - end.length);
  238. var p1 = end.c_str();
  239. for (i in 0...end.length)
  240. if (p0.at(i) != p1.at(i))
  241. return false;
  242. return true;
  243. #elseif hl
  244. var elen = end.length;
  245. var slen = s.length;
  246. return @:privateAccess (slen >= elen && s.bytes.compare((slen - elen) << 1, end.bytes, 0, elen << 1) == 0);
  247. #elseif python
  248. return python.NativeStringTools.endswith(s, end);
  249. #else
  250. var elen = end.length;
  251. var slen = s.length;
  252. return (slen >= elen && s.indexOf(end, (slen - elen)) == (slen - elen));
  253. #end
  254. }
  255. /**
  256. Tells if the character in the string `s` at position `pos` is a space.
  257. A character is considered to be a space character if its character code
  258. is 9,10,11,12,13 or 32.
  259. If `s` is the empty String `""`, or if pos is not a valid position within
  260. `s`, the result is false.
  261. **/
  262. public static function isSpace(s:String, pos:Int):Bool {
  263. #if (python || lua)
  264. if (s.length == 0 || pos < 0 || pos >= s.length)
  265. return false;
  266. #end
  267. var c = s.charCodeAt(pos);
  268. return (c > 8 && c < 14) || c == 32;
  269. }
  270. /**
  271. Removes leading space characters of `s`.
  272. This function internally calls `isSpace()` to decide which characters to
  273. remove.
  274. If `s` is the empty String `""` or consists only of space characters, the
  275. result is the empty String `""`.
  276. **/
  277. public #if cs inline #end static function ltrim(s:String):String {
  278. #if cs
  279. return untyped s.TrimStart();
  280. #else
  281. var l = s.length;
  282. var r = 0;
  283. while (r < l && isSpace(s, r)) {
  284. r++;
  285. }
  286. if (r > 0)
  287. return s.substr(r, l - r);
  288. else
  289. return s;
  290. #end
  291. }
  292. /**
  293. Removes trailing space characters of `s`.
  294. This function internally calls `isSpace()` to decide which characters to
  295. remove.
  296. If `s` is the empty String `""` or consists only of space characters, the
  297. result is the empty String `""`.
  298. **/
  299. public #if cs inline #end static function rtrim(s:String):String {
  300. #if cs
  301. return untyped s.TrimEnd();
  302. #else
  303. var l = s.length;
  304. var r = 0;
  305. while (r < l && isSpace(s, l - r - 1)) {
  306. r++;
  307. }
  308. if (r > 0) {
  309. return s.substr(0, l - r);
  310. } else {
  311. return s;
  312. }
  313. #end
  314. }
  315. /**
  316. Removes leading and trailing space characters of `s`.
  317. This is a convenience function for `ltrim(rtrim(s))`.
  318. **/
  319. public #if (cs || java) inline #end static function trim(s:String):String {
  320. #if cs
  321. return untyped s.Trim();
  322. #elseif java
  323. return (cast s : java.NativeString).trim();
  324. #else
  325. return ltrim(rtrim(s));
  326. #end
  327. }
  328. /**
  329. Concatenates `c` to `s` until `s.length` is at least `l`.
  330. If `c` is the empty String `""` or if `l` does not exceed `s.length`,
  331. `s` is returned unchanged.
  332. If `c.length` is 1, the resulting String length is exactly `l`.
  333. Otherwise the length may exceed `l`.
  334. If `c` is null, the result is unspecified.
  335. **/
  336. public static function lpad(s:String, c:String, l:Int):String {
  337. if (c.length <= 0)
  338. return s;
  339. var buf = new StringBuf();
  340. l -= s.length;
  341. while (buf.length < l) {
  342. buf.add(c);
  343. }
  344. buf.add(s);
  345. return buf.toString();
  346. }
  347. /**
  348. Appends `c` to `s` until `s.length` is at least `l`.
  349. If `c` is the empty String `""` or if `l` does not exceed `s.length`,
  350. `s` is returned unchanged.
  351. If `c.length` is 1, the resulting String length is exactly `l`.
  352. Otherwise the length may exceed `l`.
  353. If `c` is null, the result is unspecified.
  354. **/
  355. public static function rpad(s:String, c:String, l:Int):String {
  356. if (c.length <= 0)
  357. return s;
  358. var buf = new StringBuf();
  359. buf.add(s);
  360. while (buf.length < l) {
  361. buf.add(c);
  362. }
  363. return buf.toString();
  364. }
  365. /**
  366. Replace all occurrences of the String `sub` in the String `s` by the
  367. String `by`.
  368. If `sub` is the empty String `""`, `by` is inserted after each character
  369. of `s` except the last one. If `by` is also the empty String `""`, `s`
  370. remains unchanged.
  371. If `sub` or `by` are null, the result is unspecified.
  372. **/
  373. public static function replace(s:String, sub:String, by:String):String {
  374. #if java
  375. if (sub.length == 0)
  376. return s.split(sub).join(by);
  377. else
  378. return (cast s : java.NativeString).replace(sub, by);
  379. #elseif cs
  380. if (sub.length == 0)
  381. return s.split(sub).join(by);
  382. else
  383. return untyped s.Replace(sub, by);
  384. #else
  385. return s.split(sub).join(by);
  386. #end
  387. }
  388. /**
  389. Encodes `n` into a hexadecimal representation.
  390. If `digits` is specified, the resulting String is padded with "0" until
  391. its `length` equals `digits`.
  392. **/
  393. public static function hex(n:Int, ?digits:Int) {
  394. #if flash
  395. var n:UInt = n;
  396. var s:String = untyped n.toString(16);
  397. s = s.toUpperCase();
  398. #else
  399. var s = "";
  400. var hexChars = "0123456789ABCDEF";
  401. do {
  402. s = hexChars.charAt(n & 15) + s;
  403. n >>>= 4;
  404. } while (n > 0);
  405. #end
  406. #if python
  407. if (digits != null && s.length < digits) {
  408. var diff = digits - s.length;
  409. for (_ in 0...diff) {
  410. s = "0" + s;
  411. }
  412. }
  413. #else
  414. if (digits != null)
  415. while (s.length < digits)
  416. s = "0" + s;
  417. #end
  418. return s;
  419. }
  420. /**
  421. Returns the character code at position `index` of String `s`, or an
  422. end-of-file indicator at if `position` equals `s.length`.
  423. This method is faster than `String.charCodeAt()` on some platforms, but
  424. the result is unspecified if `index` is negative or greater than
  425. `s.length`.
  426. End of file status can be checked by calling `StringTools.isEof()` with
  427. the returned value as argument.
  428. This operation is not guaranteed to work if `s` contains the `\0`
  429. character.
  430. **/
  431. public static #if !eval inline #end function fastCodeAt(s:String, index:Int):Int {
  432. #if neko
  433. return untyped __dollar__sget(s.__s, index);
  434. #elseif cpp
  435. return untyped s.cca(index);
  436. #elseif flash
  437. return untyped s.cca(index);
  438. #elseif java
  439. return (index < s.length) ? cast(_charAt(s, index), Int) : -1;
  440. #elseif cs
  441. return (cast(index, UInt) < s.length) ? cast(s[index], Int) : -1;
  442. #elseif js
  443. return (cast s).charCodeAt(index);
  444. #elseif python
  445. return if (index >= s.length) -1 else python.internal.UBuiltins.ord(python.Syntax.arrayAccess(s, index));
  446. #elseif hl
  447. return @:privateAccess s.bytes.getUI16(index << 1);
  448. #elseif lua
  449. #if lua_vanilla
  450. return lua.NativeStringTools.byte(s, index + 1);
  451. #else
  452. return lua.lib.luautf8.Utf8.byte(s, index + 1);
  453. #end
  454. #else
  455. return untyped s.cca(index);
  456. #end
  457. }
  458. /**
  459. Returns an iterator of the char codes.
  460. Note that char codes may differ across platforms because of different
  461. internal encoding of strings in different runtimes.
  462. For the consistent cross-platform UTF8 char codes see `haxe.iterators.StringIteratorUnicode`.
  463. **/
  464. public static inline function iterator(s:String):StringIterator {
  465. return new StringIterator(s);
  466. }
  467. /**
  468. Returns an iterator of the char indexes and codes.
  469. Note that char codes may differ across platforms because of different
  470. internal encoding of strings in different of runtimes.
  471. For the consistent cross-platform UTF8 char codes see `haxe.iterators.StringKeyValueIteratorUnicode`.
  472. **/
  473. public static inline function keyValueIterator(s:String):StringKeyValueIterator {
  474. return new StringKeyValueIterator(s);
  475. }
  476. /**
  477. Tells if `c` represents the end-of-file (EOF) character.
  478. **/
  479. @:noUsing public static inline function isEof(c:Int):Bool {
  480. #if (flash || cpp || hl)
  481. return c == 0;
  482. #elseif js
  483. return c != c; // fast NaN
  484. #elseif (neko || lua || eval)
  485. return c == null;
  486. #elseif (cs || java || python)
  487. return c == -1;
  488. #else
  489. return false;
  490. #end
  491. }
  492. /**
  493. Returns a String that can be used as a single command line argument
  494. on Unix.
  495. The input will be quoted, or escaped if necessary.
  496. **/
  497. @:noCompletion
  498. @:deprecated('StringTools.quoteUnixArg() is deprecated. Use haxe.SysTools.quoteUnixArg() instead.')
  499. public static function quoteUnixArg(argument:String):String {
  500. return inline haxe.SysTools.quoteUnixArg(argument);
  501. }
  502. /**
  503. Character codes of the characters that will be escaped by `quoteWinArg(_, true)`.
  504. **/
  505. @:noCompletion
  506. @:deprecated('StringTools.winMetaCharacters is deprecated. Use haxe.SysTools.winMetaCharacters instead.')
  507. public static var winMetaCharacters:Array<Int> = cast haxe.SysTools.winMetaCharacters;
  508. /**
  509. Returns a String that can be used as a single command line argument
  510. on Windows.
  511. The input will be quoted, or escaped if necessary, such that the output
  512. will be parsed as a single argument using the rule specified in
  513. http://msdn.microsoft.com/en-us/library/ms880421
  514. Examples:
  515. ```haxe
  516. quoteWinArg("abc") == "abc";
  517. quoteWinArg("ab c") == '"ab c"';
  518. ```
  519. **/
  520. @:noCompletion
  521. @:deprecated('StringTools.quoteWinArg() is deprecated. Use haxe.SysTools.quoteWinArg() instead.')
  522. public static function quoteWinArg(argument:String, escapeMetaCharacters:Bool):String {
  523. return inline haxe.SysTools.quoteWinArg(argument, escapeMetaCharacters);
  524. }
  525. #if java
  526. private static inline function _charAt(str:String, idx:Int):java.StdTypes.Char16
  527. return (cast str : java.NativeString).charAt(idx);
  528. #end
  529. #if neko
  530. private static var _urlEncode = neko.Lib.load("std", "url_encode", 1);
  531. private static var _urlDecode = neko.Lib.load("std", "url_decode", 1);
  532. #end
  533. #if utf16
  534. static inline var MIN_SURROGATE_CODE_POINT = 65536;
  535. static inline function utf16CodePointAt(s:String, index:Int):Int {
  536. var c = StringTools.fastCodeAt(s, index);
  537. if (c >= 0xD800 && c <= 0xDBFF) {
  538. c = ((c - 0xD7C0) << 10) | (StringTools.fastCodeAt(s, index + 1) & 0x3FF);
  539. }
  540. return c;
  541. }
  542. #end
  543. }