PageRenderTime 51ms CodeModel.GetById 18ms RepoModel.GetById 0ms app.codeStats 0ms

/functions/funcs.strings.php

https://gitlab.com/fork/hotarucms
PHP | 607 lines | 494 code | 25 blank | 88 comment | 18 complexity | b7c0f94e7cc3bacc0324da24caa4b0c8 MD5 | raw file
Possible License(s): LGPL-2.1 
    

  1. <?php

    2. 

  2. /**

    3. 

  3.  * A collection of functions for manipulating strings

    4. 

  4.  *

    5. 

  5.  * PHP version 5

    6. 

  6.  *

    7. 

  7.  * LICENSE: Hotaru CMS is free software: you can redistribute it and/or 

    8. 

  8.  * modify it under the terms of the GNU General Public License as 

    9. 

  9.  * published by the Free Software Foundation, either version 3 of 

    10. 

  10.  * the License, or (at your option) any later version. 

    11. 

  11.  *

    12. 

  12.  * Hotaru CMS is distributed in the hope that it will be useful, but WITHOUT 

    13. 

  13.  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 

    14. 

  14.  * FITNESS FOR A PARTICULAR PURPOSE. 

    15. 

  15.  *

    16. 

  16.  * You should have received a copy of the GNU General Public License along 

    17. 

  17.  * with Hotaru CMS. If not, see http://www.gnu.org/licenses/.

    18. 

  18.  * 

    19. 

  19.  * @category  Content Management System

    20. 

  20.  * @package   HotaruCMS

    21. 

  21.  * @author    Hotaru CMS Team

    22. 

  22.  * @copyright Copyright (c) 2009 - 2013, Hotaru CMS

    23. 

  23.  * @license   http://www.gnu.org/copyleft/gpl.html GNU General Public License

    24. 

  24.  * @link      http://www.hotarucms.org/

    25. 

  25.  */

    26. 

  26.  

    27. 

  27. // We need to set the default internal encoding for the functions to operate properly.

    28. 

  28. mb_internal_encoding("UTF-8");

    29. 

  29. 

    30. 

  30. /**

    31. 

  31.  * Truncate a string

    32. 

  32.  *

    33. 

  33.  * @param string $string

    34. 

  34.  * @param int truncate to X characters

    35. 

  35.  * @para, bool $dot adds ... if true

    36. 

  36.  * @return string

    37. 

  37.  */

    38. 

  38. function truncate($string, $chars=0, $dot=true)

    39. 

  39. {

    40. 

  40. 	$length = mb_strlen($string);

    41. 

  41. 	$truncated = mb_substr(strip_tags($string), 0, $chars); // strips tags to prevent broken tags

    42. 

  42. 

    43. 

  43. 	if( $dot && ($length >= $chars) ) {

    44. 

  44. 		$truncated .= '...';

    45. 

  45. 	}

    46. 

  46. 

    47. 

  47. 	return $truncated;

    48. 

  48. }

    49. 

  49. 

    50. 

  50. 

    51. 

  51. /**

    52. 

  52.  * Strip a string from the end of a string

    53. 

  53.  *

    54. 

  54.  * @param string $string

    55. 

  55.  * @param string $remove part of the string to strip

    56. 

  56.  * @return string

    57. 

  57.  */

    58. 

  58. function rstrtrim($str, $remove=null)

    59. 

  59. {

    60. 

  60. 	$str = (string) $str;

    61. 

  61. 	$remove = (string) $remove;

    62. 

  62. 	

    63. 

  63. 	if( empty($remove) ) {

    64. 

  64. 		return rtrim($str);

    65. 

  65. 	}

    66. 

  66. 	

    67. 

  67. 	$len = mb_strlen($remove);

    68. 

  68. 	$offset = mb_strlen($str) - $len;

    69. 

  69. 	

    70. 

  70. 	while( $offset > 0 && $offset == mb_strpos($str, $remove, $offset) ) {

    71. 

  71. 		$str = mb_substr($str, 0, $offset);

    72. 

  72. 		$offset = mb_strlen($str) - $len;

    73. 

  73. 	}

    74. 

  74. 	

    75. 

  75. 	return rtrim($str);

    76. 

  76. }

    77. 

  77. 

    78. 

  78. /**

    79. 

  79.  * Changes 'plugin_name' into 'Plugin Name'

    80. 

  80.  *

    81. 

  81.  * @param string $string e.g. a plugin folder name

    82. 

  82.  * @param string $delim - the character to replace underscores with

    83. 

  83.  * @return string

    84. 

  84.  */

    85. 

  85. function make_name($string, $delim = '_', $caps = true)

    86. 

  86. {

    87. 

  87. 	$dep_array = array( );

    88. 

  88. 	$dep_array = explode($delim, trim($string));

    89. 

  89. 	if( $caps ) {

    90. 

  90. 		$dep_array = array_map('ucfirst', $dep_array);

    91. 

  91. 		$string = implode(' ', $dep_array);

    92. 

  92. 	} else {

    93. 

  93. 		$string = ucfirst(implode(' ', $dep_array));

    94. 

  94. 	}

    95. 

  95. 	

    96. 

  96. 	return $string;

    97. 

  97. }

    98. 

  98. 

    99. 

  99. 

    100. 

  100. /**

    101. 

  101.  * Generates a random string

    102. 

  102.  *

    103. 

  103.  * @param int $length 

    104. 

  104.  * @return string

    105. 

  105.  * @link http://us2.php.net/manual/en/ref.strings.php (Moe 10-July-2007)

    106. 

  106.  */

    107. 

  107. function random_string($length = 8)

    108. 

  108. {

    109. 

  109. 	$chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxwz0123456789";

    110. 

  110. 	$string = '';

    111. 

  111. 	for( $i = 0; $i < $length; $i++ ) {

    112. 

  112. 		$rand_key = mt_rand(0, strlen($chars));

    113. 

  113. 		$string .= substr($chars, $rand_key, 1);

    114. 

  114. 	}

    115. 

  115. 	return str_shuffle($string);

    116. 

  116. }

    117. 

  117. 

    118. 

  118. 

    119. 

  119. /**

    120. 

  120.  * Sanitize input

    121. 

  121.  *

    122. 

  122.  * @param string $var the string to sanitize

    123. 

  123.  * @param string $santype type of sanitation: 'all', 'ents', 'tags'

    124. 

  124.  * @param string $allowable_tags

    125. 

  125.  * @return string|false

    126. 

  126.  *

    127. 

  127.  * Note: Borrowed from SWCMS

    128. 

  128.  */

    129. 

  129. function sanitize($var, $santype = 'all', $allowable_tags = '')

    130. 

  130. {

    131. 

  131. 	// htmlentities & Strip tags

    132. 

  132. 	if( $santype == 'all' ) {

    133. 

  133. 		if( !get_magic_quotes_gpc() ) {

    134. 

  134. 			return htmlentities(strip_tags($var, $allowable_tags), ENT_QUOTES, 'UTF-8');

    135. 

  135. 		}

    136. 

  136. 		return stripslashes(htmlentities(strip_tags($var, $allowable_tags), ENT_QUOTES, 'UTF-8'));

    137. 

  137. 	}

    138. 

  138. 	

    139. 

  139. 	// Strip tags

    140. 

  140. 	if( $santype == 'tags' ) {

    141. 

  141. 		if( !get_magic_quotes_gpc() ) {

    142. 

  142. 			return strip_tags($var, $allowable_tags);

    143. 

  143. 		}

    144. 

  144. 		return stripslashes(strip_tags($var, $allowable_tags));

    145. 

  145. 	}

    146. 

  146. 	

    147. 

  147. 	// htmlentities

    148. 

  148. 	if( $santype == 'ents' ) {

    149. 

  149. 		if( !get_magic_quotes_gpc() ) {

    150. 

  150. 			return htmlentities($var, ENT_QUOTES, 'UTF-8');

    151. 

  151. 		}

    152. 

  152. 		return stripslashes(htmlentities($var, ENT_QUOTES, 'UTF-8'));

    153. 

  153. 	}

    154. 

  154. 

    155. 

  155. 	return false;

    156. 

  156. }

    157. 

  157. 

    158. 

  158. 

    159. 

  159. /**

    160. 

  160.  * Make a url friendly - a dash-separated string

    161. 

  161.  *

    162. 

  162.  * @param string $input url to format

    163. 

  163.  * @return string|false

    164. 

  164.  *

    165. 

  165.  * Note: These functions seem to overlap each other a bit...

    166. 

  166.  */

    167. 

  167. function make_url_friendly($input)

    168. 

  168. {

    169. 

  169. 	$output = replace_symbols($input);        

    170. 

  170. 	$output = mb_substr($output, 0, 240);

    171. 

  171. 	$output = mb_strtolower($output, 'UTF-8');

    172. 

  172. 	$output = trim($output);    

    173. 

  173. 	//From Wordpress and http://www.bernzilla.com/item.php?id=1007

    174. 

  174. 	$output = sanitize_title_with_dashes($output);

    175. 

  175. 	$output = urldecode($output); 

    176. 

  176. 	

    177. 

  177. 	if( $output ) {

    178. 

  178. 		return $output;

    179. 

  179. 	}

    180. 

  180. 

    181. 

  181. 	return false;

    182. 

  182. }

    183. 

  183. 

    184. 

  184. /**

    185. 

  185.  * Replace symbols and ascii characters with simpler alternatives

    186. 

  186.  *

    187. 

  187.  * @param string $input

    188. 

  188.  * @return string

    189. 

  189.  *

    190. 

  190.  * Note: Adapted from SWCMS

    191. 

  191.  */

    192. 

  192. function replace_symbols($input)

    193. 

  193. {

    194. 

  194. 	// FOR THIS TO WORK, THIS FUNCS.STRINGS.PHP FILE MUST BE SAVED 

    195. 

  195. 	// IN UTF-8 CHARACTER ENCODING !!!

    196. 

  196. 	// Replace spaces with hyphens

    197. 

  197. 	$output = preg_replace('/\s+/', '-', $input);

    198. 

  198. 	

    199. 

  199. 	// Replace other characters

    200. 

  200. 	$output = str_replace("--", "-", $output);      

    201. 

  201. 	$output = str_replace("/", "", $output);

    202. 

  202. 	$output = str_replace("\\", "", $output);

    203. 

  203. 	$output = str_replace("'", "", $output);      

    204. 

  204. 	$output = str_replace(",", "", $output);      

    205. 

  205. 	$output = str_replace(";", "", $output);      

    206. 

  206. 	$output = str_replace(":", "", $output);          

    207. 

  207. 	$output = str_replace(".", "-", $output);      

    208. 

  208. 	$output = str_replace("?", "", $output);      

    209. 

  209. 	$output = str_replace("=", "-", $output);      

    210. 

  210. 	$output = str_replace("+", "", $output); 

    211. 

  211. 	$output = str_replace("$", "", $output);          

    212. 

  212. 	$output = str_replace("&", "", $output);          

    213. 

  213. 	$output = str_replace("!", "", $output);      

    214. 

  214. 	$output = str_replace(">>", "-", $output);      

    215. 

  215. 	$output = str_replace(">", "-", $output);      

    216. 

  216. 	$output = str_replace("<<", "-", $output);      

    217. 

  217. 	$output = str_replace("<", "-", $output);      

    218. 

  218. 	$output = str_replace("*", "", $output);      

    219. 

  219. 	$output = str_replace(")", "", $output);      

    220. 

  220. 	$output = str_replace("(", "", $output);

    221. 

  221. 	$output = str_replace("[", "", $output);

    222. 

  222. 	$output = str_replace("]", "", $output);

    223. 

  223. 	$output = str_replace("^", "", $output);    

    224. 

  224. 	$output = str_replace("%", "", $output);

    225. 

  225. 	$output = str_replace("#", "", $output);

    226. 

  226. 	$output = str_replace("@", "", $output);

    227. 

  227. 	$output = str_replace("`", "", $output);

    228. 

  228. 	$output = str_replace("‘", "", $output);

    229. 

  229. 	$output = str_replace("’", "", $output);

    230. 

  230. 	$output = str_replace("“", "", $output);

    231. 

  231. 	$output = str_replace("”", "", $output);

    232. 

  232. 	$output = str_replace("~", "", $output);

    233. 

  233. 	$output = str_replace("–", "-", $output);

    234. 

  234. 	$output = str_replace("\"", "", $output);

    235. 

  235. 	$output = str_replace("|", "", $output);

    236. 

  236. 	$output = str_replace("«", "", $output);

    237. 

  237. 	$output = str_replace("»", "", $output);

    238. 

  238. 	$output = str_replace("‹", "", $output);

    239. 

  239. 	$output = str_replace("›", "", $output);

    240. 

  240. 	$output = str_replace("…", "", $output);

    241. 

  241. 	$output = str_replace("--", "-", $output);

    242. 

  242. 	$output = str_replace("---", "-", $output);

    243. 

  243. 	$output = str_replace("—", "-", $output);

    244. 

  244. 	

    245. 

  245. 	return $output;

    246. 

  246. }

    247. 

  247. 

    248. 

  248. 

    249. 

  249. /**

    250. 

  250.  * Get rid of any dangerous or unwanted characters

    251. 

  251.  *

    252. 

  252.  * @param string $title

    253. 

  253.  *

    254. 

  254.  * Note: Borrowed from Wordpress

    255. 

  255.  */

    256. 

  256. function sanitize_title_with_dashes($title)

    257. 

  257. {

    258. 

  258. 	$title = strip_tags($title);

    259. 

  259. 	

    260. 

  260. 	// Preserve escaped octets.

    261. 

  261. 	$title = preg_replace('|%([a-fA-F0-9][a-fA-F0-9])|', '---$1---', $title);

    262. 

  262. 	

    263. 

  263. 	// Remove percent signs that are not part of an octet.

    264. 

  264. 	$title = str_replace('%', '', $title);

    265. 

  265. 	

    266. 

  266. 	// Restore octets.

    267. 

  267. 	$title = preg_replace('|---([a-fA-F0-9][a-fA-F0-9])---|', '%$1', $title);

    268. 

  268. 	

    269. 

  269. 	$title = remove_accents($title);

    270. 

  270. 	

    271. 

  271. 	$title = mb_strtolower($title, 'UTF-8');

    272. 

  272. 

    273. 

  273. 	if( seems_utf8($title) ) {

    274. 

  274. 		$title = utf8_uri_encode($title, 200);

    275. 

  275. 	}

    276. 

  276. 	

    277. 

  277. 	$title = preg_replace('/&.+?;/', '', $title); // kill entities

    278. 

  278. 	$title = preg_replace('/[^%a-z0-9 _-]/', '', $title);

    279. 

  279. 	$title = preg_replace('/\s+/', '-', $title);

    280. 

  280. 	$title = preg_replace('|-+|', '-', $title);

    281. 

  281. 	$title = trim($title, '-');

    282. 

  282. 	

    283. 

  283. 	return $title;

    284. 

  284. }

    285. 

  285. 

    286. 

  286. 

    287. 

  287. /**

    288. 

  288.  * Remove accents from characters

    289. 

  289.  *

    290. 

  290.  * @param string $string

    291. 

  291.  * @return string

    292. 

  292.  *

    293. 

  293.  * Note: Borrowed from Wordpress

    294. 

  294.  */

    295. 

  295. function remove_accents($string) 

    296. 

  296. {

    297. 

  297. 	if( !preg_match('/[\x80-\xff]/', $string) ) {

    298. 

  298. 		return $string;

    299. 

  299. 	}

    300. 

  300. 

    301. 

  301. 	if( seems_utf8($string) ) {

    302. 

  302. 		$chars = array(

    303. 

  303. 		// Decompositions for Latin-1 Supplement

    304. 

  304. 		chr(195).chr(128) => 'A', chr(195).chr(129) => 'A',

    305. 

  305. 		chr(195).chr(130) => 'A', chr(195).chr(131) => 'A',

    306. 

  306. 		chr(195).chr(132) => 'A', chr(195).chr(133) => 'A',

    307. 

  307. 		chr(195).chr(135) => 'C', chr(195).chr(136) => 'E',

    308. 

  308. 		chr(195).chr(137) => 'E', chr(195).chr(138) => 'E',

    309. 

  309. 		chr(195).chr(139) => 'E', chr(195).chr(140) => 'I',

    310. 

  310. 		chr(195).chr(141) => 'I', chr(195).chr(142) => 'I',

    311. 

  311. 		chr(195).chr(143) => 'I', chr(195).chr(145) => 'N',

    312. 

  312. 		chr(195).chr(146) => 'O', chr(195).chr(147) => 'O',

    313. 

  313. 		chr(195).chr(148) => 'O', chr(195).chr(149) => 'O',

    314. 

  314. 		chr(195).chr(150) => 'O', chr(195).chr(153) => 'U',

    315. 

  315. 		chr(195).chr(154) => 'U', chr(195).chr(155) => 'U',

    316. 

  316. 		chr(195).chr(156) => 'U', chr(195).chr(157) => 'Y',

    317. 

  317. 		chr(195).chr(159) => 's', chr(195).chr(160) => 'a',

    318. 

  318. 		chr(195).chr(161) => 'a', chr(195).chr(162) => 'a',

    319. 

  319. 		chr(195).chr(163) => 'a', chr(195).chr(164) => 'a',

    320. 

  320. 		chr(195).chr(165) => 'a', chr(195).chr(167) => 'c',

    321. 

  321. 		chr(195).chr(168) => 'e', chr(195).chr(169) => 'e',

    322. 

  322. 		chr(195).chr(170) => 'e', chr(195).chr(171) => 'e',

    323. 

  323. 		chr(195).chr(172) => 'i', chr(195).chr(173) => 'i',

    324. 

  324. 		chr(195).chr(174) => 'i', chr(195).chr(175) => 'i',

    325. 

  325. 		chr(195).chr(177) => 'n', chr(195).chr(178) => 'o',

    326. 

  326. 		chr(195).chr(179) => 'o', chr(195).chr(180) => 'o',

    327. 

  327. 		chr(195).chr(181) => 'o', chr(195).chr(182) => 'o',

    328. 

  328. 		chr(195).chr(182) => 'o', chr(195).chr(185) => 'u',

    329. 

  329. 		chr(195).chr(186) => 'u', chr(195).chr(187) => 'u',

    330. 

  330. 		chr(195).chr(188) => 'u', chr(195).chr(189) => 'y',

    331. 

  331. 		chr(195).chr(191) => 'y',

    332. 

  332. 		// Decompositions for Latin Extended-A

    333. 

  333. 		chr(196).chr(128) => 'A', chr(196).chr(129) => 'a',

    334. 

  334. 		chr(196).chr(130) => 'A', chr(196).chr(131) => 'a',

    335. 

  335. 		chr(196).chr(132) => 'A', chr(196).chr(133) => 'a',

    336. 

  336. 		chr(196).chr(134) => 'C', chr(196).chr(135) => 'c',

    337. 

  337. 		chr(196).chr(136) => 'C', chr(196).chr(137) => 'c',

    338. 

  338. 		chr(196).chr(138) => 'C', chr(196).chr(139) => 'c',

    339. 

  339. 		chr(196).chr(140) => 'C', chr(196).chr(141) => 'c',

    340. 

  340. 		chr(196).chr(142) => 'D', chr(196).chr(143) => 'd',

    341. 

  341. 		chr(196).chr(144) => 'D', chr(196).chr(145) => 'd',

    342. 

  342. 		chr(196).chr(146) => 'E', chr(196).chr(147) => 'e',

    343. 

  343. 		chr(196).chr(148) => 'E', chr(196).chr(149) => 'e',

    344. 

  344. 		chr(196).chr(150) => 'E', chr(196).chr(151) => 'e',

    345. 

  345. 		chr(196).chr(152) => 'E', chr(196).chr(153) => 'e',

    346. 

  346. 		chr(196).chr(154) => 'E', chr(196).chr(155) => 'e',

    347. 

  347. 		chr(196).chr(156) => 'G', chr(196).chr(157) => 'g',

    348. 

  348. 		chr(196).chr(158) => 'G', chr(196).chr(159) => 'g',

    349. 

  349. 		chr(196).chr(160) => 'G', chr(196).chr(161) => 'g',

    350. 

  350. 		chr(196).chr(162) => 'G', chr(196).chr(163) => 'g',

    351. 

  351. 		chr(196).chr(164) => 'H', chr(196).chr(165) => 'h',

    352. 

  352. 		chr(196).chr(166) => 'H', chr(196).chr(167) => 'h',

    353. 

  353. 		chr(196).chr(168) => 'I', chr(196).chr(169) => 'i',

    354. 

  354. 		chr(196).chr(170) => 'I', chr(196).chr(171) => 'i',

    355. 

  355. 		chr(196).chr(172) => 'I', chr(196).chr(173) => 'i',

    356. 

  356. 		chr(196).chr(174) => 'I', chr(196).chr(175) => 'i',

    357. 

  357. 		chr(196).chr(176) => 'I', chr(196).chr(177) => 'i',

    358. 

  358. 		chr(196).chr(178) => 'IJ', chr(196).chr(179) => 'ij',

    359. 

  359. 		chr(196).chr(180) => 'J', chr(196).chr(181) => 'j',

    360. 

  360. 		chr(196).chr(182) => 'K', chr(196).chr(183) => 'k',

    361. 

  361. 		chr(196).chr(184) => 'k', chr(196).chr(185) => 'L',

    362. 

  362. 		chr(196).chr(186) => 'l', chr(196).chr(187) => 'L',

    363. 

  363. 		chr(196).chr(188) => 'l', chr(196).chr(189) => 'L',

    364. 

  364. 		chr(196).chr(190) => 'l', chr(196).chr(191) => 'L',

    365. 

  365. 		chr(197).chr(128) => 'l', chr(197).chr(129) => 'L',

    366. 

  366. 		chr(197).chr(130) => 'l', chr(197).chr(131) => 'N',

    367. 

  367. 		chr(197).chr(132) => 'n', chr(197).chr(133) => 'N',

    368. 

  368. 		chr(197).chr(134) => 'n', chr(197).chr(135) => 'N',

    369. 

  369. 		chr(197).chr(136) => 'n', chr(197).chr(137) => 'N',

    370. 

  370. 		chr(197).chr(138) => 'n', chr(197).chr(139) => 'N',

    371. 

  371. 		chr(197).chr(140) => 'O', chr(197).chr(141) => 'o',

    372. 

  372. 		chr(197).chr(142) => 'O', chr(197).chr(143) => 'o',

    373. 

  373. 		chr(197).chr(144) => 'O', chr(197).chr(145) => 'o',

    374. 

  374. 		chr(197).chr(146) => 'OE', chr(197).chr(147) => 'oe',

    375. 

  375. 		chr(197).chr(148) => 'R', chr(197).chr(149) => 'r',

    376. 

  376. 		chr(197).chr(150) => 'R', chr(197).chr(151) => 'r',

    377. 

  377. 		chr(197).chr(152) => 'R', chr(197).chr(153) => 'r',

    378. 

  378. 		chr(197).chr(154) => 'S', chr(197).chr(155) => 's',

    379. 

  379. 		chr(197).chr(156) => 'S', chr(197).chr(157) => 's',

    380. 

  380. 		chr(197).chr(158) => 'S', chr(197).chr(159) => 's',

    381. 

  381. 		chr(197).chr(160) => 'S', chr(197).chr(161) => 's',

    382. 

  382. 		chr(197).chr(162) => 'T', chr(197).chr(163) => 't',

    383. 

  383. 		chr(197).chr(164) => 'T', chr(197).chr(165) => 't',

    384. 

  384. 		chr(197).chr(166) => 'T', chr(197).chr(167) => 't',

    385. 

  385. 		chr(197).chr(168) => 'U', chr(197).chr(169) => 'u',

    386. 

  386. 		chr(197).chr(170) => 'U', chr(197).chr(171) => 'u',

    387. 

  387. 		chr(197).chr(172) => 'U', chr(197).chr(173) => 'u',

    388. 

  388. 		chr(197).chr(174) => 'U', chr(197).chr(175) => 'u',

    389. 

  389. 		chr(197).chr(176) => 'U', chr(197).chr(177) => 'u',

    390. 

  390. 		chr(197).chr(178) => 'U', chr(197).chr(179) => 'u',

    391. 

  391. 		chr(197).chr(180) => 'W', chr(197).chr(181) => 'w',

    392. 

  392. 		chr(197).chr(182) => 'Y', chr(197).chr(183) => 'y',

    393. 

  393. 		chr(197).chr(184) => 'Y', chr(197).chr(185) => 'Z',

    394. 

  394. 		chr(197).chr(186) => 'z', chr(197).chr(187) => 'Z',

    395. 

  395. 		chr(197).chr(188) => 'z', chr(197).chr(189) => 'Z',

    396. 

  396. 		chr(197).chr(190) => 'z', chr(197).chr(191) => 's',

    397. 

  397. 		// Euro Sign

    398. 

  398. 		chr(226).chr(130).chr(172) => 'E',

    399. 

  399. 		// GBP (Pound) Sign

    400. 

  400. 		chr(194).chr(163) => '' );

    401. 

  401. 		

    402. 

  402. 		$string = strtr($string, $chars);

    403. 

  403. 	}

    404. 

  404. 	else {

    405. 

  405. 		// Assume ISO-8859-1 if not UTF-8

    406. 

  406. 		$chars['in'] = chr(128).chr(131).chr(138).chr(142).chr(154).chr(158)

    407. 

  407. 			.chr(159).chr(162).chr(165).chr(181).chr(192).chr(193).chr(194)

    408. 

  408. 			.chr(195).chr(196).chr(197).chr(199).chr(200).chr(201).chr(202)

    409. 

  409. 			.chr(203).chr(204).chr(205).chr(206).chr(207).chr(209).chr(210)

    410. 

  410. 			.chr(211).chr(212).chr(213).chr(214).chr(216).chr(217).chr(218)

    411. 

  411. 			.chr(219).chr(220).chr(221).chr(224).chr(225).chr(226).chr(227)

    412. 

  412. 			.chr(228).chr(229).chr(231).chr(232).chr(233).chr(234).chr(235)

    413. 

  413. 			.chr(236).chr(237).chr(238).chr(239).chr(241).chr(242).chr(243)

    414. 

  414. 			.chr(244).chr(245).chr(246).chr(248).chr(249).chr(250).chr(251)

    415. 

  415. 			.chr(252).chr(253).chr(255);

    416. 

  416. 

    417. 

  417. 		$chars['out'] = "EfSZszYcYuAAAAAACEEEEIIIINOOOOOOUUUUYaaaaaaceeeeiiiinoooooouuuuyy";

    418. 

  418. 		

    419. 

  419. 		$string = strtr($string, $chars['in'], $chars['out']);

    420. 

  420. 		$double_chars['in'] = array( chr(140), chr(156), chr(198), chr(208), chr(222), chr(223), chr(230), chr(240), chr(254) );

    421. 

  421. 		$double_chars['out'] = array( 'OE', 'oe', 'AE', 'DH', 'TH', 'ss', 'ae', 'dh', 'th' );

    422. 

  422. 		$string = str_replace($double_chars['in'], $double_chars['out'], $string);

    423. 

  423.     }

    424. 

  424. 

    425. 

  425. 	return $string;

    426. 

  426. }

    427. 

  427. 

    428. 

  428. 

    429. 

  429. /**

    430. 

  430.  * Determine if the string is utf8

    431. 

  431.  *

    432. 

  432.  * @param string $str

    433. 

  433.  * @return bool

    434. 

  434.  *

    435. 

  435.  * Note: Borrowed from Wordpress (by bmorel at ssi dot fr )

    436. 

  436.  */

    437. 

  437. function seems_utf8($str)

    438. 

  438. {

    439. 

  439. 	$length = strlen($str);

    440. 

  440. 	for( $i = 0; $i < $length; $i++ ) {

    441. 

  441. 		if( ord($str[$i]) < 0x80 ) {

    442. 

  442. 			continue; // 0bbbbbbb 

    443. 

  443. 		} elseif( (ord($str[$i]) & 0xE0) == 0xC0 ) {

    444. 

  444. 			$n = 1; // 110bbbbb

    445. 

  445. 		} elseif( (ord($str[$i]) & 0xF0) == 0xE0 ) {

    446. 

  446. 			$n = 2; // 1110bbbb

    447. 

  447. 		} elseif( (ord($str[$i]) & 0xF8) == 0xF0 ) {

    448. 

  448. 			$n = 3; // 11110bbb

    449. 

  449. 		} elseif( (ord($str[$i]) & 0xFC) == 0xF8 ) {

    450. 

  450. 			$n = 4; // 111110bb

    451. 

  451. 		} elseif( (ord($str[$i]) & 0xFE) == 0xFC ) {

    452. 

  452. 			$n = 5; // 1111110b

    453. 

  453. 		} else {

    454. 

  454. 			return false; // Does not match any model

    455. 

  455. 		}

    456. 

  456. 		

    457. 

  457. 		for( $j = 0; $j < $n; $j++ ) {

    458. 

  458. 			// n bytes matching 10bbbbbb follow ?

    459. 

  459. 			if( (++$i == $length) || ((ord($str[$i]) & 0xC0) != 0x80) ) {

    460. 

  460. 				return false;

    461. 

  461. 			}

    462. 

  462. 		}

    463. 

  463. 	}

    464. 

  464. 	return true;

    465. 

  465. }

    466. 

  466. 

    467. 

  467. 

    468. 

  468. /**

    469. 

  469.  * Encodes a utf8 string

    470. 

  470.  *

    471. 

  471.  * @param string $utf8_string

    472. 

  472.  * @param int $length

    473. 

  473.  * @return string

    474. 

  474.  *

    475. 

  475.  * Note: Borrowed from Wordpress

    476. 

  476.  */

    477. 

  477. function utf8_uri_encode($utf8_string, $length = 0)

    478. 

  478. {

    479. 

  479. 	$unicode = '';

    480. 

  480. 	$values = array( );

    481. 

  481. 	$num_octets = 1;

    482. 

  482. 	$unicode_length = 0;

    483. 

  483. 

    484. 

  484. 	$string_length = strlen($utf8_string);

    485. 

  485. 	for( $i = 0; $i < $string_length; $i++ ) {

    486. 

  486. 		$value = ord($utf8_string[$i]);

    487. 

  487. 		

    488. 

  488. 		if( $value < 128 ) {

    489. 

  489. 			if( $length && ( $unicode_length >= $length ) ) {

    490. 

  490. 				break;

    491. 

  491. 			}

    492. 

  492. 			$unicode .= chr($value);

    493. 

  493. 			$unicode_length++;

    494. 

  494. 		} else {

    495. 

  495. 			if( count($values) == 0 ) {

    496. 

  496. 				$num_octets = ( $value < 224 ) ? 2 : 3;

    497. 

  497. 			}

    498. 

  498. 			

    499. 

  499. 			$values[] = $value;

    500. 

  500. 			

    501. 

  501. 			if( $length && ($unicode_length + ($num_octets * 3)) > $length ) {

    502. 

  502. 				break;

    503. 

  503. 			}

    504. 

  504. 			

    505. 

  505. 			if( count($values) == $num_octets ) {

    506. 

  506. 				if( $num_octets == 3 ) {

    507. 

  507. 					$unicode .= '%'.dechex($values[0]).'%'.dechex($values[1]).'%'.dechex($values[2]);

    508. 

  508. 					$unicode_length += 9;

    509. 

  509. 				} else {

    510. 

  510. 					$unicode .= '%'.dechex($values[0]).'%'.dechex($values[1]);

    511. 

  511. 					$unicode_length += 6;

    512. 

  512. 				}

    513. 

  513. 				

    514. 

  514. 				$values = array( );

    515. 

  515. 				$num_octets = 1;

    516. 

  516. 			}

    517. 

  517. 		}

    518. 

  518. 	}

    519. 

  519. 

    520. 

  520. 	return $unicode;

    521. 

  521. }

    522. 

  522. 

    523. 

  523. 

    524. 

  524. /**

    525. 

  525.  * Strip domain from url

    526. 

  526.  *

    527. 

  527.  * @param string $url

    528. 

  528.  * @return string|false $domain - including http://

    529. 

  529.  */

    530. 

  530. function get_domain($url = '')

    531. 

  531. {

    532. 

  532. 	$parsed = parse_url($url);

    533. 

  533. 	if( isset($parsed['scheme']) ) {

    534. 

  534. 		$domain = $parsed['scheme']."://".$parsed['host'];

    535. 

  535. 		return $domain;

    536. 

  536. 	}

    537. 

  537. 	

    538. 

  538. 	return false;

    539. 

  539. }

    540. 

  540. 

    541. 

  541. if( !function_exists("iconv") ) {

    542. 

  542. 

    543. 

  543. 	/**

    544. 

  544. 	 * Convert string to requested character encoding if iconv library not installed

    545. 

  545. 	 *

    546. 

  546. 	 * @param string $from

    547. 

  547. 	 * @param string $to

    548. 

  548. 	 * @param string $string

    549. 

  549. 	 * @return string

    550. 

  550. 	 * @link http://www.jpfox.fr/?post/2007/07/25/165-alternative-a-la-fonction-php-iconv

    551. 

  551. 	 */

    552. 

  552. 	function iconv($from, $to, $string)

    553. 

  553. 	{

    554. 

  554. 		$converted = htmlentities($string, ENT_NOQUOTES, $from); 

    555. 

  555. 		$converted = html_entity_decode($converted, ENT_NOQUOTES, $to);

    556. 

  556. 		return $converted;

    557. 

  557. 	}

    558. 

  558. 

    559. 

  559. }

    560. 

  560. 

    561. 

  561. /**

    562. 

  562.  * Count urls within a block of text

    563. 

  563.  *

    564. 

  564.  * @return int 

    565. 

  565.  * @link http://www.liamdelahunty.com/tips/php_url_count_check_for_comment_spam.php

    566. 

  566.  */

    567. 

  567. function countUrls($text = '')

    568. 

  568. {

    569. 

  569. 	//$http = substr_count($text, "http");

    570. 

  570. 	$href = substr_count($text, "href");

    571. 

  571. 	$url = substr_count($text, "[url");

    572. 

  572. 	

    573. 

  573. 	return $href + $url;

    574. 

  574. }

    575. 

  575. 

    576. 

  576. /**

    577. 

  577.  * Convert textual urls into clickable HTML links, and add nofollow.

    578. 

  578.  *

    579. 

  579.  * @param string $string

    580. 

  580.  * @return string

    581. 

  581.  */

    582. 

  582. function make_urls_clickable($string) 

    583. 

  583. {

    584. 

  584. 	$string = trim($string);

    585. 

  585. 	// Super RegEx for converting urls into clickable links unless already in an anchor tag.	

    586. 

  586. 	$string = preg_replace('|(?<!href=[\"\'])(https?://[A-Za-z0-9+\-=._/*(),@\'$:;&!?%]+)|i', '<a href="$1">$1</a>', $string);	

    587. 

  587. 	// Add nofollow to links

    588. 

  588. 	$string = preg_replace('/a[ ]+href[ ]*=[ ]*"http:\/\/(.*?)".*?/i', 'a href="http://$1" rel="nofollow"', $string);

    589. 

  589. 	return $string;

    590. 

  590. }

    591. 

  591. 

    592. 

  592. /**

    593. 

  593.  * Strip foreign characters from latin1/utf8 database yuckiness

    594. 

  594.  *

    595. 

  595.  * @param string $str

    596. 

  596.  * @return string

    597. 

  597.  */

    598. 

  598. function strip_foreign_characters($str)

    599. 

  599. {

    600. 

  600. 	$str = str_replace('Â', '', $str);

    601. 

  601. 	$str = str_replace('’', '\'', $str);

    602. 

  602. 	$str = str_replace('–', '-', $str);

    603. 

  603. 	$str = str_replace('“', '"', $str);

    604. 

  604. 	$str = str_replace('”', '"', $str);

    605. 

  605. 	return $str;

    606. 

  606. }

    607. 

  607. ?>
    608.