PageRenderTime 70ms CodeModel.GetById 28ms RepoModel.GetById 1ms app.codeStats 0ms

/common/functions.php

http://lazycms.googlecode.com/
PHP | 1966 lines | 1360 code | 60 blank | 546 comment | 300 complexity | d53e2fca89e0b490f23f8096b908086c MD5 | raw file
Possible License(s): LGPL-3.0, LGPL-2.1

Large files files are truncated, but you can click here to view the full file

    

  1. <?php
    2. 

  2. /**
    3. 

  3.  * +---------------------------------------------------------------------------+
    4. 

  4.  * | LL                             LLLL   LL     L   LLLL               LLLL  |
    5. 

  5.  * | LL                            LL   L  LLL   LL  LL   L             LL  LL |
    6. 

  6.  * | LL      LLLL   LLLLL  LL  LL  LL      LLLL LLL  LL         LL  LL      LL |
    7. 

  7.  * | LL         LL     LL  LL  LL  LL      L LLL LL  LLLLL      LL  LL     LL  |
    8. 

  8.  * | LL      LLLLL    LL    LLLL   LL      L  L  LL   LLLLL     LL  LL    LL   |
    9. 

  9.  * | LL     LL  LL   LL     LLLL   LL      L     LL      LL      LLLL    LL    |
    10. 

  10.  * | LL     LL  LL  LL       LL    LL   L  L     LL  L   LL      LLLL   LL     |
    11. 

  11.  * | LLLLLL  LLLLL  LLLLL    LL     LLLL   L     LL   LLLL        LL    LLLLLL |
    12. 

  12.  * |                        LL                                                 |
    13. 

  13.  * |                        LL                                                 |
    14. 

  14.  * +---------------------------------------------------------------------------+
    15. 

  15.  * | Copyright (C) 2007-2010 LazyCMS.com All rights reserved.                  |
    16. 

  16.  * +---------------------------------------------------------------------------+
    17. 

  17.  * | LazyCMS is free software. See LICENSE for copyright notices and details.  |
    18. 

  18.  * +---------------------------------------------------------------------------+
    19. 

  19.  */
    20. 

  20. defined('COM_PATH') or die('Restricted access!');
    21. 

  21. /**
    22. 

  22.  * LazyCMS ?????
    23. 

  23.  *
    24. 

  24.  * @author  Lukin <my@lukin.cn>
    25. 

  25.  * @version $Id: functions.php 763 2011-05-06 14:19:16Z mylukin $
    26. 

  26.  */
    27. 

  27. 

  28. 

  29. /**
    30. 

  30.  * ?? PHP info
    31. 

  31.  *
    32. 

  32.  * @return array
    33. 

  33.  */
    34. 

  34. function parse_phpinfo() {
    35. 

  35.     ob_start(); phpinfo(INFO_MODULES); $s = ob_get_contents(); ob_end_clean();
    36. 

  36.     $s = strip_tags($s, '<h2><th><td>');
    37. 

  37.     $s = preg_replace('/<th[^>]*>([^<]+)<\/th>/', '<info>\1</info>', $s);
    38. 

  38.     $s = preg_replace('/<td[^>]*>([^<]+)<\/td>/', '<info>\1</info>', $s);
    39. 

  39.     $t = preg_split('/(<h2[^>]*>[^<]+<\/h2>)/', $s, -1, PREG_SPLIT_DELIM_CAPTURE);
    40. 

  40.     $r = array(); $count = count($t);
    41. 

  41.     $p1 = '<info>([^<]+)<\/info>';
    42. 

  42.     $p2 = '/'.$p1.'\s*'.$p1.'\s*'.$p1.'/';
    43. 

  43.     $p3 = '/'.$p1.'\s*'.$p1.'/';
    44. 

  44.     for ($i = 1; $i < $count; $i++) {
    45. 

  45.         if (preg_match('/<h2[^>]*>([^<]+)<\/h2>/', $t[$i], $matchs)) {
    46. 

  46.             $name = trim($matchs[1]);
    47. 

  47.             $vals = explode("\n", $t[$i + 1]);
    48. 

  48.             foreach ($vals AS $val) {
    49. 

  49.                 if (preg_match($p2, $val, $matchs)) { // 3cols
    50. 

  50.                     $r[$name][trim($matchs[1])] = array(trim($matchs[2]), trim($matchs[3]));
    51. 

  51.                 } elseif (preg_match($p3, $val, $matchs)) { // 2cols
    52. 

  52.                     $r[$name][trim($matchs[1])] = trim($matchs[2]);
    53. 

  53.                 }
    54. 

  54.             }
    55. 

  55.         }
    56. 

  56.     }
    57. 

  57.     return $r;
    58. 

  58. }
    59. 

  59. /**
    60. 

  60.  * ???? /tags/CMS
    61. 

  61.  *
    62. 

  62.  * @param string $path
    63. 

  63.  * @return array
    64. 

  64.  */
    65. 

  65. function parse_path($path) {
    66. 

  66.     $paths  = explode('/', $path);
    67. 

  67.     $length = count($paths);
    68. 

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

  69.         if (isset($paths[$i+1])) {
    70. 

  70.             $_GET[$paths[$i]] = strval($paths[++$i]);
    71. 

  71.         }
    72. 

  72.     }
    73. 

  73.     $_REQUEST = array_merge($_POST,$_GET);
    74. 

  74.     return $paths;
    75. 

  75. }
    76. 

  76. /**
    77. 

  77.  * ?????
    78. 

  78.  *
    79. 

  79.  * @param string $path  %ID,%PY,%MD5 ? strftime() ?????
    80. 

  80.  * @param array $data
    81. 

  81.  *          array(
    82. 

  82.  *              'ID'  => 1,
    83. 

  83.  *              'PY'  => '??',
    84. 

  84.  *              'MD5' => '??ID??????????',
    85. 

  85.  *          )
    86. 

  86.  * @return string
    87. 

  87.  */
    88. 

  88. function path_format($path,$data=null) {
    89. 

  89.     if (is_array($data)) {
    90. 

  90.         $py = $id = $md5 = null;
    91. 

  91.         foreach ($data as $k=>$v) {
    92. 

  92.             if (empty($v)) continue;
    93. 

  93.             if ($k=='PY') {
    94. 

  94.                 $py = preg_replace('/[^\w\-\.\!\(\)~,#@$%^]/', '-', trim(clear_space(pinyin($v))));
    95. 

  95.             } elseif ($k=='ID') {
    96. 

  96.                 $id = $v;
    97. 

  97.             } elseif ($k=='MD5') {
    98. 

  98.                 $md5 = md5($path.$v);
    99. 

  99.             }
    100. 

  100.         }
    101. 

  101.         if ($py)  $path = str_replace(array('%PY','%py'),   $py,  $path);
    102. 

  102.         if ($id)  $path = str_replace(array('%ID','%id'),   $id,  $path);
    103. 

  103.         if ($md5) $path = str_replace(array('%MD5','%md5'), $md5, $path);
    104. 

  104.     }
    105. 

  105.     return strftime($path);
    106. 

  106. }
    107. 

  107. /**
    108. 

  108.  * W3c Datetime
    109. 

  109.  *
    110. 

  110.  * @param int $timestamp
    111. 

  111.  * @return string
    112. 

  112.  */
    113. 

  113. function W3cDate($timestamp=0) {
    114. 

  114.     if (!$timestamp) $timestamp = time();
    115. 

  115.     if (version_compare(PHP_VERSION,'5.1.0','>='))
    116. 

  116.         return date('c', $timestamp);
    117. 

  117.     
    118. 

  118.     $date    = date('Y-m-d\TH:i:s', $timestamp);
    119. 

  119.     $matches = array();
    120. 

  120.     if (preg_match('/^([\-+])(\d{2})(\d{2})$/', date('O', $timestamp), $matches)) {
    121. 

  121.         $date .= $matches[1] . $matches[2] . ':' . $matches[3];
    122. 

  122.     } else {
    123. 

  123.         $date .= 'Z';
    124. 

  124.     }
    125. 

  125.     return $date;
    126. 

  126. 

  127. }
    128. 

  128. /**
    129. 

  129.  * ?????
    130. 

  130.  *
    131. 

  131.  * @param  $format
    132. 

  132.  * @param  $time
    133. 

  133.  * @return mixed
    134. 

  134.  */
    135. 

  135. function time_format($format,$time) {
    136. 

  136.     $days   = $time>86400 ? floor($time/86400) : 0;
    137. 

  137.     $time   = $time - 86400 * $days;
    138. 

  138.     $hour   = $time>=3600 && $time<86400 ? floor($time/3600) : 0;
    139. 

  139.     $time   = $time - 86400 * $days - 3600 * $hour;
    140. 

  140.     $minute = $time>=60 && $time<3600 ? floor($time/60) : 0;
    141. 

  141.     $time   = $time - 86400 * $days - 3600 * $hour - 60 * $minute;
    142. 

  142.     $second = $time>0 && $time<60 ? $time : 0;
    143. 

  143.     $time   = floor(($time - intval($second)) * 100);
    144. 

  144.     $micro  = $time>0 ? $time : 0;
    145. 

  145.     $format = str_replace(array('%%ms','%%m','%%H','%%i','%%s'), array('$ms','$m','$H','$i','$s'),$format);
    146. 

  146.     $result = str_replace(array('%ms','%m','%H','%i','%s'), array(
    147. 

  147.         sprintf('%02d',$micro),
    148. 

  148.         sprintf('%02d',$days),
    149. 

  149.         sprintf('%02d',$hour),
    150. 

  150.         sprintf('%02d',$minute),
    151. 

  151.         sprintf('%02d',$second),
    152. 

  152.     ),$format);
    153. 

  153.     return str_replace(array('$ms','$m','$H','$i','$s'),array('%ms','%m','%H','%i','%s'),$result);
    154. 

  154. }
    155. 

  155. /**
    156. 

  156.  * ?????????
    157. 

  157.  */
    158. 

  158. function &get_conn(){
    159. 

  159.     global $db;
    160. 

  160.     if (is_null($db) || get_class($db)=='DBQuery_NOOP') {
    161. 

  161.         if (!class_exists('DBQuery'))
    162. 

  162.             include COM_PATH.'/system/dbquery.php';
    163. 

  163. 

  164.         if (defined('DB_DSN') && defined('DB_USER') && defined('DB_PWD')) {
    165. 

  165.             $db = DBQuery::factory(DB_DSN, DB_USER, DB_PWD);
    166. 

  166.         } else {
    167. 

  167.             $db = new DBQuery_NOOP();
    168. 

  168.         }
    169. 

  169.     }
    170. 

  170.     return $db;
    171. 

  171. }
    172. 

  172. /**
    173. 

  173.  * ?????
    174. 

  174.  *
    175. 

  175.  * @param  $id
    176. 

  176.  * @param  $content
    177. 

  177.  * @param  $options see http://xheditor.com/manual/2#chapter2
    178. 

  178.  * @return string
    179. 

  179.  */
    180. 

  180. function editor($id,$content,$options=null) {
    181. 

  181.     $defaults = array(
    182. 

  182.         'width'         => '680',
    183. 

  183.         'height'        => '280',
    184. 

  184.         'toobar'        => 'full',
    185. 

  185.         'emotPath'      => ROOT.'common/images/emots/',
    186. 

  186.         'editorRoot'    => ROOT.'common/editor/',
    187. 

  187.         'loadCSS'       => ROOT.'common/css/xheditor.plugins.css',
    188. 

  188.     );
    189. 

  189.     
    190. 

  190.     $options = $options ? array_merge($defaults, $options) : $defaults;
    191. 

  191. 

  192.     if (isset($options['tools'])) unset($options['toobar']);
    193. 

  193. 

  194.     if (isset($options['toobar'])) {
    195. 

  195.         switch ($options['toobar']) {
    196. 

  196.             case 'full':
    197. 

  197.                 $options['tools'] = 'Source,Preview,Pastetext,|,Blocktag,FontSize,Bold,Italic,Underline,Strikethrough,FontColor,'.
    198. 

  198.                                     'BackColor,Removeformat,|,Align,List,Outdent,Indent,|,Link,Unlink,Img,Flash,Flv,Emot,Table,GoogleMap,Pagebreak,Explorer,Removelink,LocalizedImages,|,'.
    199. 

  199.                                     'Fullscreen';
    200. 

  200.                 break;
    201. 

  201.             case 'simple':
    202. 

  202.                 $options['tools'] = 'simple';
    203. 

  203.                 break;
    204. 

  204.             case 'mini':
    205. 

  205.                 $options['tools'] = 'mini';
    206. 

  206.                 break;
    207. 

  207.         }
    208. 

  208.         unset($options['toobar']);
    209. 

  209.     }
    210. 

  210. 

  211.     $botbar = array();
    212. 

  212.     if (instr('Pagebreak', $options['tools'])) {
    213. 

  213.         $botbar[] = '<button type="button" onclick="xhe_'.$id.'.exec(\'Pagebreak\');">'.__('Insert Pagebreak').'</button>';
    214. 

  214.     }
    215. 

  215.     if (instr('Removelink', $options['tools'])) {
    216. 

  216.         $botbar[] = '<button type="button" onclick="xhe_'.$id.'.exec(\'Removelink\');">'.__('Remove external links').'</button>';
    217. 

  217.     }
    218. 

  218.     if (instr('Explorer', $options['tools'])) {
    219. 

  219.         $botbar[] = '<button type="button" onclick="xhe_'.$id.'.exec(\'Explorer\');">'.__('Explorer').'</button>';
    220. 

  220.     }
    221. 

  221.     if (instr('LocalizedImages', $options['tools'])) {
    222. 

  222.         $botbar[] = '<input cookie="true" type="checkbox" name="LocalizedImages['.$id.']" id="LocalizedImages_'.$id.'" value="1" /><label for="LocalizedImages_'.$id.'">'.__('Localized Images').'</label>';
    223. 

  223.     }
    224. 

  224.     $ht = '<textarea class="text" id="'.$id.'" name="'.$id.'">'.esc_html($content).'</textarea>';
    225. 

  225.     $ht.= '<script type="text/javascript">';
    226. 

  226.     $ht.= 'var xhe_'.$id.' = $(\'textarea[name='.$id.']\').xheditor(';
    227. 

  227.     $ht.= '$.extend('.json_encode($options).',{"onUpload":(typeof(onUpload)==\'function\' ? onUpload : null),';
    228. 

  228.     $ht.= '"upLinkUrl":LazyCMS.UpLinkUrl, "upLinkExt":LazyCMS.UpLinkExt, "upImgUrl":LazyCMS.UpImgUrl, "upImgExt":LazyCMS.UpImgExt, "upFlashUrl":LazyCMS.UpFlashUrl, "upVideoUrl":LazyCMS.UpVideoUrl, "upVideoExt":LazyCMS.UpVideoExt,';
    229. 

  229.     $ht.= '"plugins":xhePlugins, "beforeSetSource":xheFilter.SetSource, "beforeGetSource":xheFilter.GetSource';
    230. 

  230.     $ht.= '}));</script>';
    231. 

  231.     if (!empty($botbar)) $ht.= '<div class="xhe_botbar">'.implode('', $botbar).'</div>';
    232. 

  232.     return $ht;
    233. 

  233. }
    234. 

  234. 

  235. if (!function_exists('error_page')) :
    236. 

  236. /**
    237. 

  237.  * ????
    238. 

  238.  *
    239. 

  239.  * @param string $title
    240. 

  240.  * @param string $content
    241. 

  241.  * @param bool $is_full     ????????
    242. 

  242.  * @return string
    243. 

  243.  */
    244. 

  244. function error_page($title,$content,$is_full=false) {
    245. 

  245.     // CSS
    246. 

  246.     $css = '<style type="text/css">';
    247. 

  247.     $css.= '#error-page { width:600px; min-height:250px; background:#fff url('.ROOT.'common/images/warning-large.png) no-repeat 15px 10px; margin-top:15px; padding-bottom:30px; border:1px solid #B5B5B5; }';
    248. 

  248.     $css.= '#error-page { -moz-border-radius:6px; -webkit-border-radius:6px; -khtml-border-radius:6px; border-radius:6px; }';
    249. 

  249.     $css.= '#error-title { width:500px; border-bottom:solid 1px #B5B5B5; margin:0 0 15px 80px; }';
    250. 

  250.     $css.= '#error-title h1{ font-size: 25px; margin:10px 0 5px 0; }';
    251. 

  251.     $css.= '#error-content,#error-buttons { margin:10px 0 10px 80px; }';
    252. 

  252.     if ($is_full) {
    253. 

  253.         $css.= 'body { margin:10px 20px; font-family: Verdana; color: #333333; background:#FAFAFA; font-size: 12px; line-height: 1.5; }';
    254. 

  254.         $css.= '#error-page { width:900px; margin:15px auto; }';
    255. 

  255.         $css.= '#error-title { width:800px;}';
    256. 

  256.     }
    257. 

  257.     $css.= '</style>';
    258. 

  258.     // Page
    259. 

  259.     $page = '<div id="error-page">';
    260. 

  260.     $page.= '<div id="error-title"><h1>'.$title.'</h1></div>';
    261. 

  261.     $page.= '<div id="error-content">'.$content.'</div>';
    262. 

  262.     $page.= '<div id="error-buttons"><button type="button" onclick="window.history.back();">'.__('Back').'</button></div>';
    263. 

  263.     $page.= '</div>';
    264. 

  264. 

  265.     if ($is_full) {
    266. 

  266.         $hl = '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">';
    267. 

  267.         $hl.= '<html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=utf-8" />';
    268. 

  268.         $hl.= '<title>'.$title.' &#8212; LazyCMS</title>';
    269. 

  269.         $hl.= $css.'</head><body>'.$page;
    270. 

  270.         $hl.= '</body></html>';
    271. 

  271.     } else {
    272. 

  272.     	$hl = $css.$page;
    273. 

  273.     }
    274. 

  274.     return $hl;
    275. 

  275. }
    276. 

  276. endif;
    277. 

  277. 

  278. /**
    279. 

  279.  * ??????
    280. 

  280.  *
    281. 

  281.  * @param  $errno
    282. 

  282.  * @param  $errstr
    283. 

  283.  * @param  $errfile
    284. 

  284.  * @param  $errline
    285. 

  285.  * @return bool
    286. 

  286.  */
    287. 

  287. function handler_error($errno,$errstr,$errfile,$errline) {
    288. 

  288.     if (E_STRICT===$errno) return true;
    289. 

  289.     return throw_error($errstr,$errno,$errfile,$errline);
    290. 

  290. }
    291. 

  291. /**
    292. 

  292.  * ??????
    293. 

  293.  *
    294. 

  294.  * @return array
    295. 

  295.  */
    296. 

  296. function last_error($error=true) {
    297. 

  297.     global $LC_ERRNO, $LC_ERROR,$LC_ERRFILE,$LC_ERRLINE;
    298. 

  298.     // ????
    299. 

  299.     if ($error === null)
    300. 

  300.         $LC_ERRNO = $LC_ERROR = $LC_ERRFILE = $LC_ERRLINE = null;
    301. 

  301.     // ????
    302. 

  302.     if (!$LC_ERRNO) return null;
    303. 

  303.     // ???
    304. 

  304.     return array(
    305. 

  305.         'errno' => $LC_ERRNO,
    306. 

  306.         'error' => $LC_ERROR,
    307. 

  307.         'file'  => $LC_ERRFILE,
    308. 

  308.         'line'  => $LC_ERRLINE,
    309. 

  309.     );
    310. 

  310. }
    311. 

  311. /**
    312. 

  312.  * ??????
    313. 

  313.  *
    314. 

  314.  * @param  $errstr          ????
    315. 

  315.  * @param int $errno        ????
    316. 

  316.  * @return bool
    317. 

  317.  */
    318. 

  318. function throw_error($errstr,$errno=E_LAZY_NOTICE,$errfile=null,$errline=0){
    319. 

  319.     global $LC_ERRNO, $LC_ERROR,$LC_ERRFILE,$LC_ERRLINE;
    320. 

  320.     $string  = $file = null;
    321. 

  321.     $traces  = debug_backtrace();
    322. 

  322.     $error   = $traces[0]; unset($traces[0]);
    323. 

  323.     $errstr  = rel_root($errstr);
    324. 

  324.     $errfile = rel_root($errfile ? $errfile : $error['file']);
    325. 

  325.     $errline = rel_root($errline ? $errline : $error['line']);
    326. 

  326.     $LC_ERRNO = $errno; $LC_ERROR = $errstr; $LC_ERRFILE = $errfile; $LC_ERRLINE = $errline;
    327. 

  327.     if (error_reporting() === 0) return false;
    328. 

  328.     foreach($traces as $i=>$trace) {
    329. 

  329.         $file  = isset($trace['file']) ? rel_root($trace['file']) : $file;
    330. 

  330.         $line  = isset($trace['line']) ? $trace['line'] : null;
    331. 

  331.         $class = isset($trace['class']) ? $trace['class'] : null;
    332. 

  332.         $type  = isset($trace['type']) ? $trace['type'] : null;
    333. 

  333.         $args  = isset($trace['args']) ? $trace['args'] : null;
    334. 

  334.         $function  = isset($trace['function']) ? $trace['function'] : null;
    335. 

  335.         $string   .= "\t#".$i.' ['.date("y-m-d H:i:s").'] '.$file.($line?'('.$line.') ':' ');
    336. 

  336.         $string   .= $class.$type.$function.'(';
    337. 

  337.         if (is_array($args)) {
    338. 

  338.             $arrs = array();
    339. 

  339.             foreach ($args as $v) {
    340. 

  340.                 if (is_object($v)) {
    341. 

  341.                     $arrs[] = implode(' ',get_object_vars($v));
    342. 

  342.                 } else {
    343. 

  343.                     $error_level = error_reporting(0);
    344. 

  344.                     $vars = print_r($v,true);
    345. 

  345.                     error_reporting($error_level);
    346. 

  346.                     while (strpos($vars,chr(32).chr(32))!==false) {
    347. 

  347.                         $vars = str_replace(chr(32).chr(32),chr(32),$vars);
    348. 

  348.                     }
    349. 

  349.                     $arrs[] = $vars;
    350. 

  350.                 }
    351. 

  351.             }
    352. 

  352.             $string.= str_replace("\n",'',implode(', ',$arrs));
    353. 

  353.         }
    354. 

  354.         $string.=")\r\n";
    355. 

  355.     }
    356. 

  356. 

  357.     $log = "[Message]:\r\n\t{$errstr}\r\n";
    358. 

  358.     $log.= "[File]:\r\n\t{$errfile} ({$errline})\r\n";
    359. 

  359.     $log.= $string?"[Trace]:\r\n{$string}\r\n":'';
    360. 

  360.     // ????
    361. 

  361.     error_log($log, 3, ABS_PATH.'/error.log');
    362. 

  362.     // ????
    363. 

  363.     switch ($errno) {
    364. 

  364.         case E_LAZY_ERROR:
    365. 

  365.             // ?????
    366. 

  366.             if (IS_CLI) $html = $log;
    367. 

  367.             else {
    368. 

  368.                 // ????HTML
    369. 

  369.                 $html = str_replace("\t",str_repeat('&nbsp; ',2),nl2br(esc_html($log)));
    370. 

  370.                 // ??ajax???????HTML????
    371. 

  371.                 $html = is_ajax() ? $html : error_page(__('System Error'),$html,true);
    372. 

  372.             }
    373. 

  373.             // ????????????
    374. 

  374.             echo $html; exit();
    375. 

  375.             break;
    376. 

  376.         case E_LAZY_WARNING: case E_LAZY_NOTICE:
    377. 

  377.             // ?????
    378. 

  378.             if (IS_CLI) $html = $log;
    379. 

  379.             else {
    380. 

  380.                 // ????HTML
    381. 

  381.                 $html = str_replace("\t",str_repeat('&nbsp; ',2),nl2br(esc_html($log)));
    382. 

  382.                 // ??ajax???????HTML????
    383. 

  383.                 $html = is_ajax() ? $html : error_page(__('System Error'),$html,true);
    384. 

  384.             }
    385. 

  385.             echo $html;
    386. 

  386.             break;
    387. 

  387.         default: break;
    388. 

  388.     }
    389. 

  389.     return false;
    390. 

  390. }
    391. 

  391. /**
    392. 

  392.  * jQuery
    393. 

  393.  * 
    394. 

  394.  * @param string $js
    395. 

  395.  * @return string
    396. 

  396.  */
    397. 

  397. function jQuery($js) {
    398. 

  398.     if (!headers_sent())
    399. 

  399.         header('Content-Type: application/javascript; charset=utf-8');
    400. 

  400.     return sprintf('jQuery && (function($) { %s })(jQuery);', $js);
    401. 

  401. }
    402. 

  402. /**
    403. 

  403.  * ??ajax???json???
    404. 

  404.  *
    405. 

  405.  * @param string $code
    406. 

  406.  * @param mixed $data
    407. 

  407.  * @param string $eval
    408. 

  408.  * @return void
    409. 

  409.  */
    410. 

  410. function ajax_echo($code,$data,$eval=null){
    411. 

  411.     if ($code) header('X-LazyCMS-Code: '.$code);
    412. 

  412.     if ($eval) header('X-LazyCMS-Eval: '.$eval);
    413. 

  413.     // ??JSON??
    414. 

  414.     if (is_accept_json()) {
    415. 

  415.         header('Content-Type: application/json; charset=utf-8');
    416. 

  416.         echo json_encode($data);
    417. 

  417.     }
    418. 

  418.     elseif (!is_scalar($data)) {
    419. 

  419.         echo json_encode($data);
    420. 

  420.     }
    421. 

  421.     else {
    422. 

  422.         echo $data;
    423. 

  423.     }
    424. 

  424.     exit();
    425. 

  425. }
    426. 

  426. /**
    427. 

  427.  * ajax confirm
    428. 

  428.  *
    429. 

  429.  * @param string $message   ????
    430. 

  430.  * @param string $submit    ?????????
    431. 

  431.  * @param string $cancel    ?????????
    432. 

  432.  * @return void
    433. 

  433.  */
    434. 

  434. function ajax_confirm($message,$submit,$cancel=null) {
    435. 

  435.     if ($submit) header('X-LazyCMS-Submit: '.$submit);
    436. 

  436.     if ($cancel) header('X-LazyCMS-Cancel: '.$cancel);
    437. 

  437.     return ajax_echo('Confirm',$message);
    438. 

  438. }
    439. 

  439. function ajax_alert($message,$eval=null){
    440. 

  440.     return ajax_echo('Alert',$message,$eval);
    441. 

  441. }
    442. 

  442. function ajax_success($message,$eval=null){
    443. 

  443.     return ajax_echo('Success',$message,$eval);
    444. 

  444. }
    445. 

  445. function ajax_error($message,$eval=null){
    446. 

  446.     return ajax_echo('Error',$message,$eval);
    447. 

  447. }
    448. 

  448. function ajax_return($data) {
    449. 

  449.     return ajax_echo('Return', $data);
    450. 

  450. }
    451. 

  451. /**
    452. 

  452.  * ????
    453. 

  453.  *
    454. 

  454.  * @param bool $state
    455. 

  455.  * @return string
    456. 

  456.  */
    457. 

  457. function test_result($state) {
    458. 

  458.     return $state ? '<strong style="color:#009900;">&radic;</strong>' : '<strong style="color:#FF0000;">&times;</strong>';
    459. 

  459. }
    460. 

  460. /**
    461. 

  461.  * ?????IP
    462. 

  462.  *
    463. 

  463.  * @return string
    464. 

  464.  */
    465. 

  465. function get_ip() {
    466. 

  466.     if (isset($_SERVER['HTTP_X_FORWARDED_FOR'])) {
    467. 

  467.         $ip = $_SERVER['HTTP_X_FORWARDED_FOR'];
    468. 

  468.     } elseif (isset($_SERVER['HTTP_X_REAL_IP'])) {
    469. 

  469.         $ip = $_SERVER['HTTP_X_REAL_IP'];
    470. 

  470.     } elseif (isset($_SERVER['HTTP_CLIENT_IP'])) {
    471. 

  471.         $ip = $_SERVER['HTTP_CLIENT_IP'];
    472. 

  472.     } else {
    473. 

  473.         $ip = $_SERVER['REMOTE_ADDR'];
    474. 

  474.     }
    475. 

  475.     return $ip;
    476. 

  476. }
    477. 

  477. /**
    478. 

  478.  * ???????
    479. 

  479.  */
    480. 

  480. function no_cache(){
    481. 

  481.     header("Expires:".date("D,d M Y H:i:s",time()-60*10)." GMT");
    482. 

  482.     header("Last-Modified:".date("D,d M Y H:i:s")." GMT");
    483. 

  483.     header("Cache-Control:no-cache,must-revalidate");
    484. 

  484.     header("Pragma:no-cache");
    485. 

  485. }
    486. 

  486. /**
    487. 

  487.  * ????
    488. 

  488.  *
    489. 

  489.  * @param  $content
    490. 

  490.  * @return mixed
    491. 

  491.  */
    492. 

  492. function clear_space($content){
    493. 

  493.     if (strlen($content)==0) return $content; $r = $content;
    494. 

  494.     $r = str_replace(array(chr(9),chr(10),chr(13)),'',$r);
    495. 

  495.     while (strpos($r,chr(32).chr(32))!==false || strpos($r,'&nbsp;')!==false) {
    496. 

  496.         $r = str_replace(chr(32).chr(32),chr(32),str_replace('&nbsp;',chr(32),$r));
    497. 

  497.     }
    498. 

  498.     return $r;
    499. 

  499. }
    500. 

  500. /**
    501. 

  501.  * ??????????
    502. 

  502.  *
    503. 

  503.  * @param mixed  $needle   ????????
    504. 

  504.  * @param string|array $haystack ?????????????“??”?????
    505. 

  505.  * @return bool
    506. 

  506.  */
    507. 

  507. function instr($needle,$haystack){
    508. 

  508.     if (empty($haystack)) { return false; }
    509. 

  509.     if (!is_array($haystack)) $haystack = explode(',',$haystack);
    510. 

  510.     return in_array($needle,$haystack);
    511. 

  511. }
    512. 

  512. /**
    513. 

  513.  * ????
    514. 

  514.  *
    515. 

  515.  * @param string $url
    516. 

  516.  * @param int $time
    517. 

  517.  * @param string $msg
    518. 

  518.  * @return void
    519. 

  519.  */
    520. 

  520. function redirect($url,$time=0,$msg='') {
    521. 

  521. 	// ??URL????
    522. 

  522.     $url = str_replace(array("\n", "\r"), '', $url);
    523. 

  523.     if (empty($msg)) $msg = sprintf(__('<a href="%1$s">%2$d seconds after goto %1$s.</a>'),$url,$time);
    524. 

  524.     if (!headers_sent()) header("Content-Type:text/html; charset=utf-8");
    525. 

  525.     if (is_ajax()) {
    526. 

  526.         $data = array('Location' => $url);
    527. 

  527.         if ($time) $data = array_merge($data,array('Time' => $time));
    528. 

  528.         if ($time && $msg)  $data = array_merge($data,array('Message' => $msg));
    529. 

  529.         ajax_echo('Redirect',$data);
    530. 

  530.     } else {
    531. 

  531.     	if (!headers_sent()) {
    532. 

  532.     		if(0===intval($time)) {
    533. 

  533.     			header("Location: {$url}");
    534. 

  534.     		}
    535. 

  535.     	}
    536. 

  536. 		$html = '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">';
    537. 

  537. 		$html.= '<html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=utf-8" />';
    538. 

  538. 		$html.= '<meta http-equiv="refresh" content="'.$time.';url='.$url.'" />';
    539. 

  539. 		$html.= '<title>'.__('Redirecting...').'</title>';
    540. 

  540. 		$html.= '<script type="text/javascript" charset="utf-8">';
    541. 

  541.         $html.= 'window.setTimeout(function(){location.replace("'.esc_js($url).'");}, '.($time*1000).');';
    542. 

  542.         $html.= '</script>';
    543. 

  543. 		$html.= '</head><body>';
    544. 

  544. 		$html.= 0===$time ? null : $msg;
    545. 

  545. 		$html.= '</body></html>';
    546. 

  546.         exit($html);
    547. 

  547.     }
    548. 

  548. }
    549. 

  549. /**
    550. 

  550.  * ??????
    551. 

  551.  *
    552. 

  552.  * @param string $default
    553. 

  553.  * @param bool   $back_server_referer ??????
    554. 

  554.  * @return string
    555. 

  555.  */
    556. 

  556. function referer($default='',$back_server_referer=true){
    557. 

  557.     $default = $default?$default:ROOT;
    558. 

  558.     $referer = isset($_REQUEST['referer'])?$_REQUEST['referer']:null;
    559. 

  559.     if ($back_server_referer) {
    560. 

  560.         if(empty($referer) && isset($_SERVER['HTTP_REFERER'])) {
    561. 

  561.             $referer = $_SERVER['HTTP_REFERER'];
    562. 

  562.         } else {
    563. 

  563.             $referer = esc_html($referer);
    564. 

  564.         }
    565. 

  565.     } else {
    566. 

  566.         if(empty($referer)) {
    567. 

  567.             $referer = $default;
    568. 

  568.         } else {
    569. 

  569.             $referer = esc_html($referer);
    570. 

  570.         }
    571. 

  571. 

  572.     }
    573. 

  573. 

  574.     if(strpos($referer, 'login.php')!==false) $referer = $default;
    575. 

  575.     return $referer;
    576. 

  576. }
    577. 

  577. /**
    578. 

  578.  * ??????????????????????????
    579. 

  579.  *
    580. 

  580.  * @param   string  $path
    581. 

  581.  * @return  string  ???????????????
    582. 

  582.  */
    583. 

  583. function rel_root($path){
    584. 

  584.     $abs_path = str_replace(DIRECTORY_SEPARATOR,'/',ABS_PATH.DIRECTORY_SEPARATOR);
    585. 

  585.     $src_path = str_replace(DIRECTORY_SEPARATOR,'/',$path);
    586. 

  586.     return str_replace($abs_path, (IS_CLI ? '/' : ROOT), $src_path);
    587. 

  587. }
    588. 

  588. /**
    589. 

  589.  * ??sql??
    590. 

  590.  *
    591. 

  591.  * @param  $str
    592. 

  592.  * @return string
    593. 

  593.  */
    594. 

  594. function esc_sql($str) {
    595. 

  595.     return get_conn()->escape($str);
    596. 

  596. }
    597. 

  597. /**
    598. 

  598.  * ???????HTML??
    599. 

  599.  *
    600. 

  600.  * @param   string $str
    601. 

  601.  * @return  string
    602. 

  602.  */
    603. 

  603. function esc_html($str){
    604. 

  604.     if(empty($str)) {
    605. 

  605.         return $str;
    606. 

  606.     } elseif (is_array($str)) {
    607. 

  607. 		$str = array_map('esc_html', $str);
    608. 

  608. 	} elseif (is_object($str)) {
    609. 

  609. 		$vars = get_object_vars($str);
    610. 

  610. 		foreach ($vars as $key=>$data) {
    611. 

  611. 			$str->{$key} = esc_html($data);
    612. 

  612. 		}
    613. 

  613. 	} else {
    614. 

  614.         $str = htmlspecialchars($str);
    615. 

  615.     }
    616. 

  616.     return $str;
    617. 

  617. }
    618. 

  618. /**
    619. 

  619.  * Escapes strings to be included in javascript
    620. 

  620.  *
    621. 

  621.  * @param string $str
    622. 

  622.  * @return mixed
    623. 

  623.  */
    624. 

  624. function esc_js($str) {
    625. 

  625.     return preg_replace('/([^ :!#$%@()*+,-.\x30-\x5b\x5d-\x7e])/e',
    626. 

  626.         "'\\x'.(ord('\\1')<16? '0': '').dechex(ord('\\1'))", $str);
    627. 

  627. }
    628. 

  628. /**
    629. 

  629.  * ?????
    630. 

  630.  *
    631. 

  631.  * @param array $input array('a'=>0.5,'b'=>0.2,'c'=>0.4)
    632. 

  632.  * @param int $pow ?????
    633. 

  633.  * @return array key
    634. 

  634.  */
    635. 

  635. function random($input, $pow = 2) {
    636. 

  636.     $much = pow(10, $pow);
    637. 

  637.     $max  = array_sum($input) * $much;
    638. 

  638.     $rand = mt_rand(1, $max);
    639. 

  639.     $base = 0;
    640. 

  640.     foreach ($input as $k => $v) {
    641. 

  641.         $min = $base * $much + 1;
    642. 

  642.         $max = ($base + $v) * $much;
    643. 

  643.         if ($min <= $rand && $rand <= $max) {
    644. 

  644.             return $k;
    645. 

  645.         } else {
    646. 

  646.             $base += $v;
    647. 

  647.         }
    648. 

  648.     }
    649. 

  649.     return false;
    650. 

  650. }
    651. 

  651. /**
    652. 

  652.  * ?????
    653. 

  653.  *
    654. 

  654.  * @param int $length
    655. 

  655.  * @param string $charlist
    656. 

  656.  * @return string
    657. 

  657.  */
    658. 

  658. function str_rand($length=6,$charlist='0123456789abcdefghijklmnopqrstopwxyz'){
    659. 

  659.     $charcount = strlen($charlist); $str = null;
    660. 

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

  661.         $str.= $charlist[mt_rand(0,$charcount-1)];
    662. 

  662.     }
    663. 

  663.     return $str;
    664. 

  664. }
    665. 

  665. /**
    666. 

  666.  * ????XML
    667. 

  667.  *
    668. 

  668.  * @param string $content
    669. 

  669.  * @return mixed
    670. 

  670.  */
    671. 

  671. function xmlencode($content){
    672. 

  672.     if (strlen($content) == 0) return $content;
    673. 

  673.     return str_replace(
    674. 

  674.         array('&',"'",'"','>','<'),
    675. 

  675.         array('&amp;','&apos;','&quot;','&gt;','&lt;'),
    676. 

  676.         $content
    677. 

  677.     );
    678. 

  678. }
    679. 

  679. /**
    680. 

  680.  * XMLdecode
    681. 

  681.  *
    682. 

  682.  * @param string $content
    683. 

  683.  * @return mixed
    684. 

  684.  */
    685. 

  685. function xmldecode($content){
    686. 

  686.     if (strlen($content) == 0) return $content;
    687. 

  687.     return str_replace(
    688. 

  688.         array('&amp;','&apos;','&quot;','&gt;','&lt;'),
    689. 

  689.         array('&',"'",'"','>','<'),
    690. 

  690.         $content
    691. 

  691.     );
    692. 

  692. }
    693. 

  693. /**
    694. 

  694.  * ?????UTF-8??
    695. 

  695.  *
    696. 

  696.  * @param   string
    697. 

  697.  * @return  bool
    698. 

  698.  */
    699. 

  699. function is_utf8($str){
    700. 

  700.     return preg_match('%^(?:
    701. 

  701.         [\x09\x0A\x0D\x20-\x7E]             # ASCII
    702. 

  702.         | [\xC2-\xDF][\x80-\xBF]            # non-overlong 2-byte
    703. 

  703.         | \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
    704. 

  704.         | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
    705. 

  705.         | \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
    706. 

  706.         | \xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
    707. 

  707.         | [\xF1-\xF3][\x80-\xBF]{3}         # planes 4-15
    708. 

  708.         | \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
    709. 

  709.         )*$%xs',$str);
    710. 

  710. }
    711. 

  711. /**
    712. 

  712.  * ?????ajax??
    713. 

  713.  *
    714. 

  714.  * @return bool
    715. 

  715.  */
    716. 

  716. function is_ajax(){
    717. 

  717. 	return (isset($_SERVER['HTTP_X_REQUESTED_WITH'])?$_SERVER['HTTP_X_REQUESTED_WITH']:null)=='XMLHttpRequest';
    718. 

  718. }
    719. 

  719. /**
    720. 

  720.  * ??????
    721. 

  721.  *
    722. 

  722.  * @param array $array
    723. 

  723.  * @return bool
    724. 

  724.  */
    725. 

  725. function is_assoc($array) {
    726. 

  726.     return (is_array($array) && (0 !== count(array_diff_key($array, array_keys(array_keys($array)))) || count($array)==0));
    727. 

  727. }
    728. 

  728. /**
    729. 

  729.  * ??????????
    730. 

  730.  *
    731. 

  731.  * @param mixed $data Value to check to see if was serialized.
    732. 

  732.  * @return bool
    733. 

  733.  */
    734. 

  734. function is_serialized($data) {
    735. 

  735.     // if it isn't a string, it isn't serialized
    736. 

  736.     if (!is_string($data))
    737. 

  737.         return false;
    738. 

  738.     $data = trim($data);
    739. 

  739.     if ('N;' == $data)
    740. 

  740.         return true;
    741. 

  741.     if (!preg_match('/^([adObis]):/', $data, $badions))
    742. 

  742.         return false;
    743. 

  743.     switch ($badions[1]) {
    744. 

  744.         case 'a' :
    745. 

  745.         case 'O' :
    746. 

  746.         case 's' :
    747. 

  747.             if (preg_match("/^{$badions[1]}:[0-9]+:.*[;}]\$/s", $data))
    748. 

  748.                 return true;
    749. 

  749.             break;
    750. 

  750.         case 'b' :
    751. 

  751.         case 'i' :
    752. 

  752.         case 'd' :
    753. 

  753.             if (preg_match("/^{$badions[1]}:[0-9.E-]+;\$/", $data))
    754. 

  754.                 return true;
    755. 

  755.             break;
    756. 

  756.     }
    757. 

  757.     return false;
    758. 

  758. }
    759. 

  759. /**
    760. 

  760.  * ??????JSON??
    761. 

  761.  * 
    762. 

  762.  * @return bool
    763. 

  763.  */
    764. 

  764. function is_accept_json() {
    765. 

  765.     return strpos(strtolower($_SERVER['HTTP_ACCEPT']),'application/json')!==false;
    766. 

  766. }
    767. 

  767. /**
    768. 

  768.  * ????json
    769. 

  769.  *
    770. 

  770.  * @param string $string
    771. 

  771.  * @return bool
    772. 

  772.  */
    773. 

  773. function is_json($string){
    774. 

  774.     return preg_match('/^("(\\.|[^"\n\r])*?"|[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t])+?$/',$string);
    775. 

  775. }
    776. 

  776. /**
    777. 

  777.  * stripslashes ??
    778. 

  778.  *
    779. 

  779.  * @param   array     $value     ??????
    780. 

  780.  * @return  mixed
    781. 

  781.  */
    782. 

  782. function stripslashes_deep($value) {
    783. 

  783.     if (is_array($value)) {
    784. 

  784. 		$value = array_map('stripslashes_deep', $value);
    785. 

  785. 	} elseif (is_object($value)) {
    786. 

  786. 		$vars = get_object_vars($value);
    787. 

  787. 		foreach ($vars as $key=>$data) {
    788. 

  788. 			$value->{$key} = stripslashes_deep($data);
    789. 

  789. 		}
    790. 

  790. 	} else {
    791. 

  791. 		$value = stripslashes($value);
    792. 

  792. 	}
    793. 

  793. 	return $value;
    794. 

  794. }
    795. 

  795. /**
    796. 

  796.  * ????
    797. 

  797.  *
    798. 

  798.  * @param string $content		???????
    799. 

  799.  * @param int    $level			???????3?????????
    800. 

  800.  * @param bool   $force_gzip	????gzip???true
    801. 

  801.  */
    802. 

  802. function ob_compress($content,$level=3,$force_gzip=false){
    803. 

  803.     if (strlen($content)>2048
    804. 

  804.             && false == headers_sent()
    805. 

  805.             && false == ini_get('zlib.output_compression')
    806. 

  806.             && 'ob_gzhandler' != ini_get('output_handler')) {
    807. 

  807.         header('Vary: Accept-Encoding'); // Handle proxies
    808. 

  808.         if ( false !== strpos( strtolower($_SERVER['HTTP_ACCEPT_ENCODING']), 'deflate')
    809. 

  809.                 && function_exists('gzdeflate')
    810. 

  810.                 && ! $force_gzip ) {
    811. 

  811.             header('Content-Encoding: deflate');
    812. 

  812.             $content = gzdeflate( $content, $level );
    813. 

  813.         } elseif ( false !== strpos( strtolower($_SERVER['HTTP_ACCEPT_ENCODING']), 'gzip')
    814. 

  814.                 && function_exists('gzencode') ) {
    815. 

  815.             header('Content-Encoding: gzip');
    816. 

  816.             $content = gzencode( $content, $level );
    817. 

  817.         }
    818. 

  818.         header("Content-Length: ".strlen($content));
    819. 

  819.     }
    820. 

  820.     return $content;
    821. 

  821. }
    822. 

  822. /**
    823. 

  823.  * ?????????
    824. 

  824.  *
    825. 

  825.  * $start,$end,$clear ????????“/”?????????
    826. 

  826.  * $clear ????
    827. 

  827.  *
    828. 

  828.  * @param string $content           ??
    829. 

  829.  * @param string $start             ????
    830. 

  830.  * @param string $end               ????
    831. 

  831.  * @param string|array $clear      ????
    832. 

  832.  * @return string
    833. 

  833.  */
    834. 

  834. function mid($content,$start,$end=null,$clear=null){
    835. 

  835.     if (empty($content) || empty($start)) return null;
    836. 

  836.     if ( strncmp($start, '/', 1) === 0) {
    837. 

  837.         if (preg_match($start, $content, $args)) {
    838. 

  838.             $start = $args[0];
    839. 

  839.         }
    840. 

  840.     }
    841. 

  841.     if ( $end && strncmp($end, '/', 1) === 0 ) {
    842. 

  842.         if (preg_match($end, $content, $args)) {
    843. 

  843.             $end = $args[0];
    844. 

  844.         }
    845. 

  845.     }
    846. 

  846.     $start_len = strlen($start); $result = null;
    847. 

  847.     $start_pos = stripos($content,$start); if ($start_pos === false) return null;
    848. 

  848.     $length    = $end===null ? null : stripos(substr($content,-(strlen($content)-$start_pos-$start_len)),$end);
    849. 

  849.     if ($start_pos !== false) {
    850. 

  850.         if ($length === null) {
    851. 

  851.             $result = trim(substr($content, $start_pos + $start_len));
    852. 

  852.         } else {
    853. 

  853.             $result = trim(substr($content, $start_pos + $start_len, $length));
    854. 

  854.         }
    855. 

  855.     }
    856. 

  856.     if ($result && $clear) {
    857. 

  857.         if (is_array($clear)) {
    858. 

  858.             foreach ($clear as $v) {
    859. 

  859.                 if ( strncmp($v, '/', 1) === 0 ) {
    860. 

  860.                     $result = preg_replace($v, '', $result);
    861. 

  861.                 } else {
    862. 

  862.                     if (strpos($result, $v) !== false) {
    863. 

  863.                         $result = str_replace($v, '', $result);
    864. 

  864.                     }
    865. 

  865.                 }
    866. 

  866.             }
    867. 

  867.         } else {
    868. 

  868.             if ( strncmp($clear, '/', 1) === 0 ) {
    869. 

  869.                 $result = preg_replace($clear, '', $result);
    870. 

  870.             } else {
    871. 

  871.                 if (strpos($result,$clear) !== false) {
    872. 

  872.                     $result = str_replace($clear, '', $result);
    873. 

  873.                 }
    874. 

  874.             }
    875. 

  875.         }
    876. 

  876.     }
    877. 

  877.     return $result;
    878. 

  878. }
    879. 

  879. /**
    880. 

  880.  * ???URL??
    881. 

  881.  *
    882. 

  882.  * ??url???????
    883. 

  883.  *
    884. 

  884.  * @param string $base  ????
    885. 

  885.  * @param string $html  html??
    886. 

  886.  * @return string
    887. 

  887.  */
    888. 

  888. function format_url($base, $html) {
    889. 

  889.     if (preg_match_all('/<(img|script)[^>]+src=([^\s]+)[^>]*>|<(a|link)[^>]+href=([^\s]+)[^>]*>/iU', $html, $matchs)) {
    890. 

  890.         $pase_url  = parse_url($base);
    891. 

  891.         $base_host = sprintf('%s://%s',   $pase_url['scheme'], $pase_url['host']);
    892. 

  892.         if (($pos=strpos($pase_url['path'], '#')) !== false) {
    893. 

  893.             $base_path = rtrim(dirname(substr($pase_url['path'], 0, $pos)), '\\/');
    894. 

  894.         } else {
    895. 

  895.             $base_path = rtrim(dirname($pase_url['path']), '\\/');
    896. 

  896.         }
    897. 

  897.         $base_url = $base_host.$base_path;
    898. 

  898.         foreach($matchs[0] as $match) {
    899. 

  899.             if (preg_match('/^(.+(href|src)=)([^ >]+)(.+?)$/i', $match, $args)) {
    900. 

  900.                 $url = trim(trim($args[3],'"'),"'");
    901. 

  901.                 // http ?????
    902. 

  902.                 if (preg_match('/^(http|https|ftp)\:\/\//i', $url)) continue;
    903. 

  903.                 // ?????javascript
    904. 

  904.                 if (strncasecmp($url, 'mailto:', 7)===0 || strncasecmp($url, 'javascript:', 11)===0) continue;
    905. 

  905.                 // ????
    906. 

  906.                 if (strncmp($url, '/', 1) === 0) {
    907. 

  907.                     $url = $base_host.$url;
    908. 

  908.                 }
    909. 

  909.                 // ????
    910. 

  910.                 elseif (strncmp($url, '../', 3) === 0) {
    911. 

  911.                     while (strncmp($url, '../', 3) === 0) {
    912. 

  912.                         $url = substr($url, -(strlen($url)-3));
    913. 

  913.                         if(strlen($base_path) > 0){
    914. 

  914.                             $base_path = dirname($base_path);
    915. 

  915.                         }
    916. 

  916.                         if ($url == '../') {
    917. 

  917.                             $url = ''; break;
    918. 

  918.                         }
    919. 

  919.                     }
    920. 

  920.                     $url = $base_host.$base_path.'/'.$url;
    921. 

  921.                 }
    922. 

  922.                 // ????
    923. 

  923.                 elseif (strncmp($url, './', 2) === 0) {
    924. 

  924.                     $url = $base_url.'/'.substr($url, 2);
    925. 

  925.                 }
    926. 

  926.                 // ??
    927. 

  927.                 else {
    928. 

  928.                     $url = $base_url.'/'.$url;
    929. 

  929.                 }
    930. 

  930.                 // ????
    931. 

  931.                 $html = str_replace($match, sprintf('%s"%s"%s', $args[1], $url, $args[4]), $html);
    932. 

  932.             }
    933. 

  933.         }
    934. 

  934.     }
    935. 

  935.     return $html;
    936. 

  936. }
    937. 

  937. /**
    938. 

  938.  * ?????
    939. 

  939.  *
    940. 

  940.  * @param int $bytes
    941. 

  941.  * @return string
    942. 

  942.  */
    943. 

  943. function format_size($bytes){
    944. 

  944.     if ($bytes == 0) return '-';
    945. 

  945.     $units = array('Bytes', 'KB', 'MB', 'GB', 'TB', 'PB');
    946. 

  946.     $i = 0; while ($bytes >= 1024) { $bytes /= 1024; $i++; }
    947. 

  947.     $precision = $i == 0 ? 0 : 2;
    948. 

  948.     return number_format(round($bytes, $precision), $precision) . ' ' . $units[$i];
    949. 

  949. }
    950. 

  950. /**
    951. 

  951.  * ??????
    952. 

  952.  *
    953. 

  953.  * @param string $string
    954. 

  954.  * @param int $start
    955. 

  955.  * @param int $end
    956. 

  956.  * @return bool|string
    957. 

  957.  */
    958. 

  958. function substring($string, $start, $end=null) {
    959. 

  959.     if ($end === null) {
    960. 

  960.         return substr($string, $start);
    961. 

  961.     } elseif($end > $start) {
    962. 

  962.         return substr($string, $start, $end - $start);
    963. 

  963.     } else {
    964. 

  964.         return false;
    965. 

  965.     }
    966. 

  966. }
    967. 

  967. /**
    968. 

  968.  * IP??????
    969. 

  969.  *
    970. 

  970.  * @param string $ip
    971. 

  971.  * @return string
    972. 

  972.  */
    973. 

  973. function ip2addr($ip) {
    974. 

  974.     static $QQWry;
    975. 

  975. 	if ( is_null($QQWry) ) {
    976. 

  976.         include_file(COM_PATH.'/system/qqwry.php');
    977. 

  977.         $QQWry = new QQWry(COM_PATH.'/QQWry.Dat');
    978. 

  978.     }
    979. 

  979.     return $QQWry->ip2addr($ip);
    980. 

  980. }
    981. 

  981. /**
    982. 

  982.  * ?????
    983. 

  983.  *
    984. 

  984.  * @param string $image
    985. 

  985.  * @param int $max_w
    986. 

  986.  * @param int $max_h
    987. 

  987.  * @param null $toname
    988. 

  988.  * @return bool|null
    989. 

  989.  */
    990. 

  990. function image_thumb($image, $max_w=100, $max_h=100, $toname=null) {
    991. 

  991.     if (!class_exists('Image')) {
    992. 

  992.         include_file(COM_PATH.'/system/image.php');
    993. 

  993.     }
    994. 

  994.     return Image::thumb($image, $max_w, $max_h, $toname);
    995. 

  995. }
    996. 

  996. /**
    997. 

  997.  * jsmin
    998. 

  998.  *
    999. 

  999.  * @param string $js
    1000. 

  1000.  * @return string
    1001. 

  1001.  */
    1002. 

  1002. function jsmin($js) {
    1003. 

  1003.     if (!class_exists('JSMin')) {
    1004. 

  1004.         include_file(COM_PATH.'/system/jsmin.php');
    1005. 

  1005.     }
    1006. 

  1006.     return JSMin::minify($js);
    1007. 

  1007. }
    1008. 

  1008. /**
    1009. 

  1009.  * ????
    1010. 

  1010.  *
    1011. 

  1011.  * @param string $str
    1012. 

  1012.  * @param bool $ucfirst ?????
    1013. 

  1013.  * @return string
    1014. 

  1014.  */
    1015. 

  1015. function pinyin($str, $ucfirst=true) {
    1016. 

  1016.     if (!function_exists('_pinyin_get_object')) {
    1017. 

  1017.         include_file(COM_PATH.'/system/pinyin.php');
    1018. 

  1018.     }
    1019. 

  1019.     $pinyin = _pinyin_get_object();
    1020. 

  1020.     return $pinyin->encode($str, $ucfirst);
    1021. 

  1021. }
    1022. 

  1022. /**
    1023. 

  1023.  * ????
    1024. 

  1024.  *
    1025. 

  1025.  * @param string $url   $ ??????
    1026. 

  1026.  * @param string $mode  ??????
    1027. 

  1027.  * @param int $page     ????
    1028. 

  1028.  * @param int $total    ???
    1029. 

  1029.  * @param int $length   ??????
    1030. 

  1030.  * @return string
    1031. 

  1031.  */
    1032. 

  1032. function pages_list($url,$mode='$',$page=null,$total=null,$length=null) {
    1033. 

  1033.     if (!function_exists('_pages_get_object')) {
    1034. 

  1034.         include_file(COM_PATH.'/system/pages.php');
    1035. 

  1035.     }
    1036. 

  1036.     $pages = _pages_get_object();
    1037. 

  1037.     if ($page !== null)   $pages->page   = $page;
    1038. 

  1038.     if ($total !== null)  $pages->pages  = $total;
    1039. 

  1039.     if ($length !== null) $pages->length = $length;
    1040. 

  1040.     return $pages->page_list($url, $mode);
    1041. 

  1041. }
    1042. 

  1042. /**
    1043. 

  1043.  * ??HTTP?????
    1044. 

  1044.  *
    1045. 

  1045.  * @param int $code HTTP status code.
    1046. 

  1046.  * @return string Empty string if not found, or description if found.
    1047. 

  1047.  */
    1048. 

  1048. function http_status_desc($code) {
    1049. 

  1049.     if (!function_exists('_httplib_get_object')) {
    1050. 

  1050.         include_file(COM_PATH.'/system/httplib.php');
    1051. 

  1051.     }
    1052. 

  1052.     $http = _httplib_get_object();
    1053. 

  1053.     return $http->status_desc($code);
    1054. 

  1054. }
    1055. 

  1055. /**
    1056. 

  1056.  * ????
    1057. 

  1057.  *
    1058. 

  1058.  * @param string $timezone
    1059. 

  1059.  * @return bool
    1060. 

  1060.  */
    1061. 

  1061. function time_zone_set($timezone) {
    1062. 

  1062.     if (!function_exists('_timezone_get_object')) {
    1063. 

  1063.         include_file(COM_PATH.'/system/timezone.php');
    1064. 

  1064.     }
    1065. 

  1065.     $zone = _timezone_get_object();
    1066. 

  1066.     return $zone->set_zone($timezone);
    1067. 

  1067. }
    1068. 

  1068. /**
    1069. 

  1069.  * ???????
    1070. 

  1070.  *
    1071. 

  1071.  * @return array
    1072. 

  1072.  */
    1073. 

  1073. function time_zone_group() {
    1074. 

  1074.     if (!function_exists('_timezone_get_object')) {
    1075. 

  1075.         include_file(COM_PATH.'/system/timezone.php');
    1076. 

  1076.     }
    1077. 

  1077.     $zone = _timezone_get_object();
    1078. 

  1078.     return $zone->get_group();
    1079. 

  1079. }
    1080. 

  1080. /**
    1081. 

  1081.  * ??????
    1082. 

  1082.  *
    1083. 

  1083.  * @param string $func
    1084. 

  1084.  * @param mixed $args
    1085. 

  1085.  * @return bool
    1086. 

  1086.  */
    1087. 

  1087. function func_add_callback() {
    1088. 

  1088.     global $LC_func_callback;
    1089. 

  1089. 

  1090.     if (!is_array($LC_func_callback))
    1091. 

  1091.         $LC_func_callback = array();
    1092. 

  1092.     
    1093. 

  1093.     $args = func_get_args();
    1094. 

  1094.     $func = array_shift($args);
    1095. 

  1095.     
    1096. 

  1096.     $LC_func_callback[] = array(
    1097. 

  1097.         'func' => $func,
    1098. 

  1098.         'args' => $args,
    1099. 

  1099.     );
    1100. 

  1100.     return true;
    1101. 

  1101. }
    1102. 

  1102. /**
    1103. 

  1103.  * ??
    1104. 

  1104.  *
    1105. 

  1105.  * @param string $email
    1106. 

  1106.  * @param int $size
    1107. 

  1107.  * @param string $default
    1108. 

  1108.  * @return string
    1109. 

  1109.  */
    1110. 

  1110. function get_avatar($email, $size=96, $default='') {
    1111. 

  1111.     if ( !empty($email) )
    1112. 

  1112. 		$email_hash = md5( strtolower( $email ) );
    1113. 

  1113. 

  1114.     if ( !empty($email) )
    1115. 

  1115.         $host = sprintf( "http://%d.gravatar.com", ( hexdec( $email_hash{0} ) % 2 ) );
    1116. 

  1116.     else
    1117. 

  1117.         $host = 'http://0.gravatar.com';
    1118. 

  1118. 

  1119.     if ( 'mystery' == $default )
    1120. 

  1120.         $default = "{$host}/avatar/ad516503a11cd5ca435acc9bb6523536.gif?s={$size}"; // ad516503a11cd5ca435acc9bb6523536 == md5('unknown@gravatar.com')
    1121. 

  1121.     elseif ( 'blank' == $default )
    1122. 

  1122. 		$default = HTTP_HOST.ROOT.'common/images/blank.gif';
    1123. 

  1123.     elseif ( empty($email) )
    1124. 

  1124. 		$default = "{$host}/avatar/00000000000000000000000000000000.gif?d={$default}&amp;s={$size}";
    1125. 

  1125. 

  1126.     if ( !empty($email) ) {
    1127. 

  1127.         $result = "{$host}/avatar/{$email_hash}.gif?s={$size}&amp;d=".urlencode( $default )."&amp;r=g";
    1128. 

  1128.     } else {
    1129. 

  1129.         $result = $default;
    1130. 

  1130.     }
    1131. 

  1131.     return $result;
    1132. 

  1132. }
    1133. 

  1133. /**
    1134. 

  1134.  * ???
    1135. 

  1135.  *
    1136. 

  1136.  * @param string $name
    1137. 

  1137.  * @param string $alt
    1138. 

  1138.  * @return string
    1139. 

  1139.  */
    1140. 

  1140. function get_icon($name,$alt='') {
    1141. 

  1141.     switch ($name) {
    1142. 

  1142.         case 'passed':      $name = 'b8'; break;
    1143. 

  1143.         case 'draft':       $name = 'b9'; break;
    1144. 

  1144.         case 'enabled':     $name = 'c3'; break;
    1145. 

  1145.         case 'disabled':    $name = 'c4'; break;
    1146. 

  1146.     }
    1147. 

  1147.     return '<img src="'.ROOT.'common/images/blank.gif" class="os '.$name.'" alt="'.$alt.'" />';
    1148. 

  1148. }
    1149. 

  1149. /**
    1150. 

  1150.  * ?????????????????
    1151. 

  1151.  *
    1152. 

  1152.  * @param string $path    ??
    1153. 

  1153.  * @param string $ext     ????
    1154. 

  1154.  * @return array
    1155. 

  1155.  */
    1156. 

  1156. function get_dir_array($path,$ext='*'){
    1157. 

  1157.     $path = str_replace(array('.','[',']'),array(DIRECTORY_SEPARATOR,'*','*'),$path);
    1158. 

  1158.     if (!strncasecmp($path,'@',1)) {
    1159. 

  1159.         $path = str_replace('@',COM_PATH,$path);
    1160. 

  1160.     } else {
    1161. 

  1161.         $path = ABS_PATH.DIRECTORY_SEPARATOR.$path;
    1162. 

  1162.     }
    1163. 

  1163.     $process_func = create_function('&$path,$ext','$path=substr($path,strrpos($path,"/")+1);');
    1164. 

  1164.     if (!substr_compare($path,'/',strlen($path)-1,1)===false) $path .= '/';
    1165. 

  1165.     $result = ($ext=='dir') ? glob("{$path}*",GLOB_ONLYDIR) : glob("{$path}*.{{$ext}}",GLOB_BRACE);
    1166. 

  1166.     array_walk($result,$process_func);
    1167. 

  1167.     return $result;
    1168. 

  1168. }
    1169. 

  1169. /**
    1170. 

  1170.  * ??????
    1171. 

  1171.  *
    1172. 

  1172.  * @return bool
    1173. 

  1173.  */
    1174. 

  1174. function include_modules() {
    1175. 

  1175.     static $loaded; if ($loaded) return true;
    1176. 

  1176.     // ???????
    1177. 

  1177.     include_file(COM_PATH.'/system/template.php');
    1178. 

  1178.     // ?????
    1179. 

  1179.     include_file(COM_PATH.'/system/pages.php');
    1180. 

  1180.     // ??????
    1181. 

  1181.     $modules = get_dir_array('@/module','php');
    1182. 

  1182.     foreach ($modules as $file) {
    1183. 

  1183.         include_file(COM_PATH.'/module/'.$file);
    1184. 

  1184.     }
    1185. 

  1185.     // ??????
    1186. 

  1186.     global $LC_func_callback;
    1187. 

  1187.     if ($LC_func_callback) {
    1188. 

  1188.         foreach ((array)$LC_func_callback as $call) {
    1189. 

  1189.             if (function_exists($call['func'])) call_user_func_array($call['func'], $call['args']);
    1190. 

  1190.         }
    1191. 

  1191.     }
    1192. 

  1192.     $loaded = true; return true;
    1193. 

  1193. }
    1194. 

  1194. /**
    1195. 

  1195.  * ????????
    1196. 

  1196.  *
    1197. 

  1197.  * @param string $path      ??
    1198. 

  1198.  * @param string $ext       ??
    1199. 

  1199.  * @param string $html      html??? ???????#value#,#name#,#selected#
    1200. 

  1200.  * @param string $selected  selected
    1201. 

  1201.  */
    1202. 

  1202. function options($path,$ext,$html,$selected=null){
    1203. 

  1203.     $type = $ext=='lang' ? 'mo' : $ext;
    1204. 

  1204.     $dirs = get_dir_array($path,$type); $result = null;
    1205. 

  1205.     if (strpos($html,'%23')!==false) { $html = str_replace('%23','#',$html); }
    1206. 

  1206.     foreach ($dirs as $v) {
    1207. 

  1207.         if ($ext=='lang') {
    1208. 

  1208.             $v   = basename($v,'.mo');
    1209. 

  1209.             $val = code2lang($v);
    1210. 

  1210.         } else{
    1211. 

  1211.             $val = $v;
    1212. 

  1212.         }
    1213. 

  1213.         $opt = $html;
    1214. 

  1214.         if (strpos($opt,'#value#')!==false) { $opt = str_replace('#value#',$v,$opt); }
    1215. 

  1215.         if (strpos($opt,'#name#')!==false)  { $opt = str_replace('#name#',$val,$opt); }
    1216. 

  1216.         if ($selected==$v) {
    1217. 

  1217.             $opt = str_replace('#selected#',' selected="selected"',$opt);
    1218. 

  1218.         } else{
    1219. 

  1219.             $opt = str_replace('#selected#','',$opt);
    1220. 

  1220.         }
    1221. 

  1221.         $result.= $opt;
    1222. 

  1222.     }
    1223. 

  1223.     return $result;
    1224. 

  1224. }
    1225. 

  1225. 

  1226. /**
    1227. 

  1227.  * ??????? ??????
    1228. 

  1228.  *
    1229. 

  1229.  * @param string $from
    1230. 

  1230.  * @param string $to
    1231. 

  1231.  * @param mixed  $data
    1232. 

  1232.  * @return mixed
    1233. 

  1233.  */
    1234. 

  1234. function iconvs($from,$to,$data){
    1235. 

  1235.     $from = strtoupper($from)=='UTF8'? 'UTF-8':$from;
    1236. 

  1236.     $to   = strtoupper($to)=='UTF8'? 'UTF-8':$to;
    1237. 

  1237.     if ( strtoupper($from) === strtoupper($to) || empty($data) || (is_scalar($data) && !is_string($data)) ){
    1238. 

  1238.         //??????????????????
    1239. 

  1239.         return $data;
    1240. 

  1240.     }
    1241. 

  1241.     if (is_string($data) ) {
    1242. 

  1242.         if(function_exists('iconv')) {
    1243. 

  1243.             $to = substr($to,-8)=='//IGNORE' ? $to : $to.'//IGNORE';
    1244. 

  1244.             return iconv($from,$to,$data);
    1245. 

  1245.         } elseif (function_exists('mb_convert_encoding')) {
    1246. 

  1246.             return mb_convert_encoding ($data, $to, $from);
    1247. 

  1247.         } else {
    1248. 

  1248.             return $data;
    1249. 

  1249.         }
    1250. 

  1250.     }
    1251. 

  1251.     elseif (is_array($data)){
    1252. 

  1252.         foreach ( $data as $key => $val ) {
    1253. 

  1253.             $_key        = iconvs($from,$to,$key);
    1254. 

  1254.             $data[$_key] = iconvs($from,$to,$val);
    1255. 

  1255.             if ($key != $_key ) {
    1256. 

  1256.                 unset($data[$key]);
    1257. 

  1257.             }
    1258. 

  1258.         }
    1259. 

  1259.         return $data;
    1260. 

  1260.     }
    1261. 

  1261.     else {
    1262. 

  1262.         return $data;
    1263. 

  1263.     }
    1264. 

  1264. }
    1265. 

  1265. /**
    1266. 

  1266.  * ??????
    1267. 

  1267.  *
    1268. 

  1268.  * @param string $path   ?????
    1269. 

  1269.  * @param int    $mode   ??
    1270. 

  1270.  * @return bool
    1271. 

  1271.  */
    1272. 

  1272. function mkdirs($path, $mode = 0777){
    1273. 

  1273.     if (!is_dir($path)) {
    1274. 

  1274.         mkdirs(dirname($path), $mode);
    1275. 

  1275.         $error_level = error_reporting(0);
    1276. 

  1276.         $result      = mkdir($path, $mode);
    1277. 

  1277.         error_reporting($error_level);
    1278. 

  1278.         return $result;
    1279. 

  1279.     }
    1280. 

  1280.     return true;
    1281. 

  1281. }
    1282. 

  1282. /**
    1283. 

  1283.  * ?????
    1284. 

  1284.  *
    1285. 

  1285.  * @param string $path		?????????
    1286. 

  1286.  * @return bool
    1287. 

  1287.  */
    1288. 

  1288. function rmdirs($path){
    1289. 

  1289.     // ????????
    1290. 

  1290.     if ($path=='/' || realpath($path)==ABS_PATH)
    1291. 

  1291.         return false;
    1292. 

  1292.     $error_level = error_reporting(0);
    1293. 

  1293.     if ($dh = opendir($path)) {
    1294. 

  1294.         while (false !== ($file=readdir($dh))) {
    1295. 

  1295.             if ($file != '.' && $file != '..') {
    1296. 

  1296.                 $file_path = $path.'/'.$file;
    1297. 

  1297.                 is_dir($file_path) ? rmdirs($file_path) : unlink($file_path);
    1298. 

  1298.             }
    1299. 

  1299.         }
    1300. 

  1300.         closedir($dh);
    1301. 

  1301.     }
    1302. 

  1302.     $result = rmdir($path);
    1303. 

  1303.     error_reporting($error_level);
    1304. 

  1304.     return $result;
    1305. 

  1305. }
    1306. 

  1306. /**
    1307. 

  1307.  * ?? require_once
    1308. 

  1308.  *
    1309. 

  1309.  * @param  $path
    1310. 

  1310.  * @return bool
    1311. 

  1311.  */
    1312. 

  1312. function include_file($path){
    1313. 

  1313.     static $paths = array();
    1314. 

  1314.     if (is_file($path)) {
    1315. 

  1315.         if (!isset($paths[$path])) {
    1316. 

  1316.             include $path;
    1317. 

  1317.             $paths[$path] = true;
    1318. 

  1318.             return true;
    1319. 

  1319.         }
    1320. 

  1320.         return false;
    1321. 

  1321.     }
    1322. 

  1322.     return false;
    1323. 

  1323. }
    1324. 

  1324. if (!function_exists('authcode')) :
    1325. 

  1325. /**
    1326. 

  1326.  * ???????CODE
    1327. 

  1327.  *
    1328. 

  1328.  * @param string $data
    1329. 

  1329.  * @return string
    1330. 

  1330.  */
    1331. 

  1331. function authcode($data=null){
    1332. 

  1332.     return guid(HTTP_HOST.$data.get_ip().$_SERVER['HTTP_USER_AGENT']);
    1333. 

  1333. }
    1334. 

  1334. endif;
    1335. 

  1335. /**
    1336. 

  1336.  * ??guid
    1337. 

  1337.  *
    1338. 

  1338.  * @param  $randid  ???
    1339. 

  1339.  * @return string   guid
    1340. 

  1340.  */
    1341. 

  1341. function guid($mix=null){
    1342. 

  1342.     if (is_null($mix)) {
    1343. 

  1343.         $randid = uniqid(mt_rand(),true);
    1344. 

  1344.     } else {
    1345. 

  1345.         if (is_object($mix) && function_exists('spl_object_hash')) {
    1346. 

  1346.             $randid = spl_object_hash($mix);
    1347. 

  1347.         } elseif (is_resource($mix)) {
    1348. 

  1348.             $randid = get_resource_type($mix).strval($mix);
    1349. 

  1349.         } else {
    1350. 

  1350.             $randid = serialize($mix);
    1351. 

  1351.         }
    1352. 

  1352.     }
    1353. 

  1353.     $randid = strtoupper(md5($randid));
    1354. 

  1354.     $hyphen = chr(45);
    1355. 

  1355.     $result = array();
    1356. 

  1356.     $result[] = substr($randid, 0, 8);
    1357. 

  1357.     $result[] = substr($randid, 8, 4);
    1358. 

  1358.     $result[] = substr($randid, 12, 4);
    1359. 

  1359.     $result[] = substr($randid, 16, 4);
    1360. 

  1360.     $result[] = substr($randid, 20, 12);
    1361. 

  1361.     return implode($hyphen,$result);
    1362. 

  1362. }
    1363. 

  1363. /**
    1364. 

  1364.  * ?????
    1365. 

  1365.  *
    1366. 

  1366.  * @param string $code    ????????
    1367. 

  1367.  * @return string
    1368. 

  1368.  */
    1369. 

  1369. function code2lang($code){
    1370. 

  1370.     $lang = array(
    1371. 

  1371.         'af'	=> __('Afrikaans'),
    1372. 

  1372.         'sq'	=> __('Albanian'),
    1373. 

  1373.         'ar'	=> __('Arabic'),
    1374. 

  1374.         'be'	=> __('Belarusian'),
    1375. 

  1375.         'bg'	=> __('Bulgarian'),
    1376. 

  1376.         'ca'	=> __('Catalan'),
    1377. 

  1377.         'zh-CN'	=> __('Chinese (Simplified)'),
    1378. 

  1378.         'zh-TW'	=> __('Chinese (Traditional)'),
    1379. 

  1379.         'hr'	=> __('Croatian'),
    1380. 

  1380.         'cs'	=> __('Czech'),
    1381. 

  1381.         'da'	=> __('Danish'),
    1382. 

  1382.         'nl'	=> __('Dutch'),
    1383. 

  1383.         'en'	=> __('English'),
    1384. 

  1384.         'et'	=> __('Estonian'),
    1385. 

  1385.         'tl'	=> __('Filipino'),
    1386. 

  1386.         'fi'	=> __('Finnish'),
    1387. 

  1387.         'fr'	=> __('French'),
    1388. 

  1388.         'gl'	=> __('Galician'),
    1389. 

  1389.         'de'	=> __('German'),
    1390. 

  1390.         'el'	=> __('Greek'),
    1391. 

  1391.         'iw'	=> __('Hebrew'),
    1392. 

  1392.         'hi'	=> __('Hindi'),
    1393. 

  1393.         'hu'	=> __('Hungarian'),
    1394. 

  1394.         'is'	=> __('Icelandic'),
    1395. 

  1395.         'id'	=> __('Indonesian'),
    1396. 

  1396.         'ga'	=> __('Irish'),
    1397. 

  1397.         'it'	=> __('Italian'),
    1398. 

  1398.         'ja'	=> __('Japanese'),
    1399. 

  1399.         'ko'	=> __('Korean'),
    1400. 

  1400.         'lv'	=> __('Latvian'),
    1401. 

  1401.         'lt'	=> __('Lithuanian'),
    1402. 

  1402.         'mk'	=> __('Macedonian'),
    1403. 

  1403.         'ms'	=> __('Malay'),
    1404. 

  1404.         'mt'	=> __('Maltese'),
    1405. 

  1405.         'no'	=> __('Norwegian'),
    1406. 

  1406.         'fa'	=> __('Persian'),
    1407. 

  1407.         'pl'	=> __('Polish'),
    1408. 

  1408.         'pt'	=> __('Portuguese'),
    1409. 

  1409.         'ro'	=> __('Romanian'),
    1410. 

  1410.         'ru'	=> __('Russian'),
    1411. 

  1411.         'sr'	=> __('Serbian'),
    1412. 

  1412.         'sk'	=> __('Slovak'),
    1413. 

  1413.         'sl'	=> __('Slovenian'),
    1414. 

  1414.         'es'	=> __('Spanish'),
    1415. 

  1415.         'sw'	=> __('Swahili'),
    1416. 

  1416.         'sv'	=> __('Swedish'),
    1417. 

  1417.         'th'	=> __('Thai'),
    1418. 

  1418.         'tr'	=> __('Turkish'),
    1419. 

  1419.         'uk'	=> __('Ukrainian'),
    1420. 

  1420.         'vi'	=> __('Vietnamese'),
    1421. 

  1421.         'cy'	=> __('Welsh'),
    1422. 

  1422.         'yi'	=> __('Yiddish'),
    1423. 

  1423.     );
    1424. 

  1424.     return isset($lang[$code])?$lang[$code]:$code;
    1425. 

  1425. }
    1426. 

  1426. /**
    1427. 

  1427.  * ???????
    1428. 

  1428.  *
    1429. 

  1429.  * @return string
    1430. 

  1430.  */
    1431. 

  1431. function language() {
    1432. 

  1432.     $ck_lang = cookie_get('language');
    1433. 

  1433.     $ck_lang = preg_replace( '/[^a-z0-9,_-]+/i', '', $ck_lang ); 
    1434. 

  1434. 

  1435.     if (empty($ck_lang) && isset($_SERVER['HTTP_ACCEPT_LANGUAGE'])) {
    1436. 

  1436.         $ck_lang = $_SERVER['HTTP_ACCEPT_LANGUAGE'];
    1437. 

  1437.         if (($pos=strpos($ck_lang,',')) !== false) {
    1438. 

  1438.             $ck_lang = substr($ck_lang,0,$pos);
    1439. 

  1439.         }
    1440. 

  1440.         // ???????
    1441. 

  1441.         if (strtolower($ck_lang) == 'zh-cn') {
    1442. 

  1442.             $ck_lang = 'zh-CN';
    1443. 

  1443.         } elseif (strtolower($ck_lang) == 'zh-tw') {
    1444. 

  1444.             $ck_lang = 'zh-TW';
    1445. 

  1445.         }
    1446. 

  1446.     } elseif(empty($ck_lang)) {
    1447. 

  1447.         $ck_lang = C('Language');
    1448. 

  1448.     }
    1449. 

  1449.     return $ck_lang;
    1450. 

  1450. }
    1451. 

  1451. /**
    1452. 

  1452.  * ????
    1453. 

  1453.  *
    1454. 

  1454.  * @param string|array $key
    1455. 

  1455.  * @param mixed $value
    1456. 

  1456.  * @return mixed
    1457. 

  1457.  */
    1458. 

  1458. function C($key,$value=null){
    1459. 

  1459.     $ckey = 'cfg.'; $args = null;
    1460. 

  1460.     // ????
    1461. 

  1461.     if(is_array($key)) {
    1462. 

  1462.         foreach ($key as $k=>$v) {
    1463. 

  1463.         	C($k,$v);
    1464. 

  1464.         }
    1465. 

  1465.         return true;
    1466. 

  1466.     }
    1467. 

  1467.     // ??key
    1468. 

  1468.     if (strpos($key,'.')!==false) {
    1469. 

  1469.     	$args   = explode('.',$key);
    1470. 

  1470.     	$module = array_shift($args);
    1471. 

  1471.     	$code   = array_shift($args);
    1472. 

  1472.     } else {
    1473. 

  1473.         $module = 'System';
    1474. 

  1474.     	$code   = $key;
    1475. 

  1475.     }
    1476. 

  1476.     $db  = @get_conn();
    1477. 

  1477.     $key = $module.'.'.$code;
    1478. 

  1478.     // ??
    1479. 

  1479.     if($key && func_num_args()==1) {
    1480. 

  1480.         // ????????
    1481. 

  1481.         if ($db && !$db->ready) return null;
    1482. 

  1482.         // ???????
    1483. 

  1483.         $value = fcache_get($ckey.$key);
    1484. 

  1484.         if (fcache_is_null($value)) {
    1485. 

  1485.             if ($db->is_table('#@_option')) {
    1486. 

  1486.                 $result = $db->query("SELECT `value` FROM `#@_option` WHERE `module`='%s' AND `code`='%s' LIMIT 1 OFFSET 0;",array($module,$code));
    1487. 

  1487.                 if ($data = $db->fetch($result)) {
    1488. 

  1488.                     $value = is_serialized($data['value']) ? unserialize($data['value']) : $data['value'];
    1489. 

  1489.                     // ?????
    1490. 

  1490.                     fcache_set($ckey.$key,$value);
    1491. 

  1491.                 }
    1492. 

  1492.             }
    1493. 

  1493.         }
    1494. 

  1494.         // ????????
    1495. 

  1495.         if (!empty($args) && is_array($value)) {
    1496. 

  1496.         	foreach ($args as $arg) {
    1497. 

  1497.         		$value = $value[$arg];
    1498. 

  1498.         	}
    1499. 

  1499.         }
    1500. 

  1500.         return $value;
    1501. 

  1501.     }
    1502. 

  1502.     // ????
    1503. 

  1503.     else {
    1504. 

  1504.         // ????
    1505. 

  1505.         if (is_null($value)) {
    1506. 

  1506.             fcache_delete($key);
    1507. 

  1507.             $db->delete('#@_option',array(
    1508. 

  1508.                 'module' => $module,
    1509. 

  1509.                 'code'   => $code,
    1510. 

  1510.             ));
    1511. 

  1511.         } else {
    1512. 

  1512.             // ?????
    1513. 

  1513.             fcache_set($ckey.$key,$value);
    1514. 

  1514.             // ????????????
    1515. 

  1515.             $length = (int) $db->result(vsprintf("SELECT COUNT(`id`) FROM `#@_option` WHERE `module`='%s' AND `code`='%s'",array(esc_sql($module),esc_sql($code))));
    1516. 

  1516.             // update
    1517. 

  1517.             if ($length > 0) {
    1518. 

  1518.                 $db->update('#@_option',array(
    1519. 

  1519.                    'value' => $value,
    1520. 

  1520.                 ),array(
    1521. 

  1521.                     'module' => $module,
    1522. 

  1522.                     'code'   => $code,
    1523. 

  1523.                 ));
    1524. 

  1524.             }
    1525. 

  1525.             // insert
    1526. 

  1526.             else {
    1527. 

  1527.                 // ???????
    1528. 

  1528.                 $db->insert('#@_option',array(
    1529. 

  1529.                     'module' => $module,
    1530. 

  1530.                     'code'   => $code,
    1531. 

  1531.                     'value'  => $value,
    1532. 

  1532.                 ));
    1533. 

  1533.             }
    1534. 

  1534.         }
    1535. 

  1535.         return true;
    1536. 

  1536.     }
    1537. 

  1537.     return null;
    1538. 

  1538. }
    1539. 

  1539. 

  1540. if (!function_exists('json_encode')) {
    1541. 

  1541.     function json_encode($value){
    1542. 

  1542.         global $_json;
    1543. 

  1543.         if (!$_json) {
    1544. 

  1544.             include_file(COM_PATH.'/system/json.php');
    1545. 

  1545.             $_json = new Services_JSON(SERVICES_JSON_LOOSE_TYPE);
    1546. 

  1546.         }
    1547. 

  1547.         return $_json->encode($value);
    1548. 

  1548.     }
    1549. 

  1549. }
    1550. 

  1550. 

  1551. if (!function_exists('json_decode')) {
    1552. 

  1552.     function json_decode($json){
    1553. 

  1553.         global $_json;
    1554. 

  1554.         if (!$_json) {
    1555. 

  1555.             include_file(COM_PATH.'/system/json.php');
    1556. 

  1556.             $_json = new Services_JSON(SERVICES_JSON_LOOSE_TYPE);
    1557. 

  1557.         }
    1558. 

  1558.         return $_json->decode($json);
    1559. 

  1559.     }
    1560. 

  1560. }
    1561. 

  1561. 

  1562. if (!function_exists('mb_substr')) {
    1563. 

  1563.     function mb_substr( $str, $start, $length=null, $encoding='UTF-8' ) {
    1564. 

  1564.         if ( !instr( $encoding, 'utf8,utf-8,UTF8,UTF-8' ) ) {
    1565. 

  1565.             return is_null( $length )? substr( $str, $start ) : substr( $str, $start, $length);
    1566. 

  1566.         }
    1567. 

  1567.         if (function_exists('iconv_substr')){
    1568. 

  1568.             return iconv_substr($str,$start,$length,$encoding);
    1569. 

  1569.         }
    1570. 

  1570.         // use the regex unicode support to separate the UTF-8 characters into an array
    1571. 

  1571.         preg_match_all( '/./us', $str, $match );
    1572. 

  1572.         $chars = is_null( $length )? array_slice( $match[0], $start ) : array_slice( $match[0], $start, $length );
    1573. 

  1573.         return implode( '', $chars );
    1574. 

  1574.     }
    1575. 

  1575. }
    1576. 

  1576. 

  1577. if (!function_exists('mb_strlen')) {
    1578. 

  1578.     function mb_strlen( $str, $encoding='UTF-8' ) {
    1579. 

  1579.         if ( !instr( $encoding, 'utf8,utf-8,UTF8,UTF-8' ) ) {
    1580. 

  1580.             return strlen($str);
    1581. 

  1581.         }
    1582. 

  1582.         if (function_exists('iconv_strlen')){
    1583. 

  1583.             return iconv_strlen($str,$encoding);
    1584. 

  1584.         }
    1585. 

  1585.         // use the regex unicode support to separate the UTF-8 characters into an array
    1586. 

  1586.         preg_match_all( '/./us', $str, $match );
    1587. 

  1587.         return count($match);
    1588. 

  1588.     }
    1589. 

  1589. }
    1590. 

  1590. 

  1591. if (!function_exists('hash_hmac')){
    1592. 

  1592.     function hash_hmac($algo, $data, $key, $raw_output = false) {
    1593. 

  1593.         $packs = array('md5' => 'H32', 'sha1' => 'H40');
    1594. 

  1594. 

  1595.         if ( !isset($packs[$algo]) )
    1596. 

  1596.             return false;
    1597. 

  1597. 

  1598.         $pack = $packs[$algo];
    1599. 

  1599. 

  1600.         if (strlen($key) > 64)
    1601. 

  1601.             $key = pack($pack, $algo($key));
    1602. 

  1602.         else if (strlen($key) < 64)
    1603. 

  1603.             $key = str_pad($key, 64, chr(0));
    1604. 

  1604. 

  1605.         $ipad = (substr($key, 0, 64) ^ str_repeat(chr(0x36), 64));
    1606. 

  1606.         $opad = (substr($key, 0, 64) ^ str_repeat(chr(0x5C), 64));
    1607. 

  1607. 

  1608.         return $algo($opad . pack($pack, $algo($ipad . $data)));
    1609. 

  1609.     }
    1610. 

  1610. }
    1611. 

  1611. 

  1612. if (!function_exists('http_build_query')) {
    1613. 

  1613.     // from php.net (modified by Mark Jaquith to behave like the native PHP5 function)
    1614. 

  1614. 	function http_build_query($data, $prefix=null, $sep=null, $key='', $urlencode=true) {
    1615. 

  1615. 		$ret = array();
    1616. 

  1616. 

  1617.         foreach ( (array) $data as $k => $v ) {
    1618. 

  1618.             if ( $urlencode)
    1619. 

  1619.                 $k = urlencode($k);
    1620. 

  1620.             if ( is_int($k) && $prefix != null )
    1621. 

  1621.                 $k = $prefix.$k;
    1622. 

  1622.             if ( !empty($key) )
    1623. 

  1623.                 $k = $key . '%5B' . $k . '%5D';
    1624. 

  1624.             if ( $v === NULL )
    1625. 

  1625.                 continue;
    1626. 

  1626.             elseif ( $v === FALSE )
    1627. 

  1627.                 $v = '0';
    1628. 

  1628. 

  1629.             if ( is_array($v) || is_object($v) )
    1630. 

  1630.                 array_push($ret, http_build_query($v, '', $sep, $k, $urlencode));
    1631. 

  1631.             elseif ( $urlencode )
    1632. 

  1632.                 array_push($ret, $k.'='.urlencode($v));
    1633. 

  1633.             else
    1634. 

  1634.                 array_push($ret, $k.'='.$v);
    1635. 

  1635.         }
    1636. 

  1636. 

  1637.         if ( NULL === $sep )
    1638. 

  1638.             $sep = ini_get('arg_separator.output');
    1639. 

  1639. 

  1640.         return implode($sep, $ret);
    1641. 

  1641. 	}
    1642. 

  1642. }
    1643. 

  1643. 

  1644. if (!function_exists('substr_compare')) {
    1645. 

  1645.    function substr_compare($main_str, $str, $offset…
    1646.

Large files files are truncated, but you can click here to view the full file