root/trunk/lib/SGL/String.php

Revision 3125, 24.1 kB (checked in by demian, 3 weeks ago)

bugfix to trunk merge -3

Line 
1 <?php
2 /* Reminder: always indent with 4 spaces (no tabs). */
3 // +---------------------------------------------------------------------------+
4 // | Copyright (c) 2006, Demian Turner                                         |
5 // | All rights reserved.                                                      |
6 // |                                                                           |
7 // | Redistribution and use in source and binary forms, with or without        |
8 // | modification, are permitted provided that the following conditions        |
9 // | are met:                                                                  |
10 // |                                                                           |
11 // | o Redistributions of source code must retain the above copyright          |
12 // |   notice, this list of conditions and the following disclaimer.           |
13 // | o Redistributions in binary form must reproduce the above copyright       |
14 // |   notice, this list of conditions and the following disclaimer in the     |
15 // |   documentation and/or other materials provided with the distribution.    |
16 // | o The names of the authors may not be used to endorse or promote          |
17 // |   products derived from this software without specific prior written      |
18 // |   permission.                                                             |
19 // |                                                                           |
20 // | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS       |
21 // | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT         |
22 // | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR     |
23 // | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT      |
24 // | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,     |
25 // | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT          |
26 // | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,     |
27 // | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY     |
28 // | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT       |
29 // | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE     |
30 // | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.      |
31 // |                                                                           |
32 // +---------------------------------------------------------------------------+
33 // | Seagull 0.6                                                               |
34 // +---------------------------------------------------------------------------+
35 // | String.php                                                                |
36 // +---------------------------------------------------------------------------+
37 // | Author:   Demian Turner <demian@phpkitchen.com>                           |
38 // +---------------------------------------------------------------------------+
39 // $Id: String.php,v 1.14 2005/06/01 11:11:23 demian Exp $
40
41 define('SGL_CENSOR_DISABLE',        0);
42 define('SGL_CENSOR_EXACT_MATCH',    1);
43 define('SGL_CENSOR_WORD_BEGINNING', 2);
44 define('SGL_CENSOR_WORD_FRAGMENT'3);
45
46 /**
47  * Various string helper methods.
48  *
49  * @package SGL
50  * @author  Demian Turner <demian@phpkitchen.com>
51  * @version $Revision: 1.14 $
52  */
53 class SGL_String
54 {
55     /**
56      * Censors profanity.
57      *
58      * @author  Tony Bibbs  <tony@tonybibbs.com>
59      * @access  public
60      * @static
61      * @param   string  $text           string to check
62      * @return  string  $editedText     edited text
63      */
64     function censor($text)
65     {
66         SGL::logMessage(null, PEAR_LOG_DEBUG);
67         $c = &SGL_Config::singleton();
68         $conf = $c->getAll();
69
70         $editedText = $text;
71         $censorMode = SGL_String::pseudoConstantToInt($conf['censor']['mode']);
72         if ($censorMode != SGL_CENSOR_DISABLE) {
73             $aBadWords = explode(',', $conf['censor']['badWords']);
74             if (is_array($aBadWords)) {
75                 $replacement = $conf['censor']['replaceString'];
76
77                 switch ($censorMode) {
78                 case SGL_CENSOR_EXACT_MATCH:
79                     $regExPrefix = '(\s*)';
80                     $regExSuffix = '(\W*)';
81                     break;
82                 case SGL_CENSOR_WORD_BEGINNING:
83                     $regExPrefix = '(\s*)';
84                     $regExSuffix = '(\w*)';
85                     break;
86                 case SGL_CENSOR_WORD_FRAGMENT:
87                     $regExPrefix   = '(\w*)';
88                     $regExSuffix   = '(\w*)';
89                     break;
90                 }
91                 for ($i = 0; $i < count($aBadWords); $i++ ) {
92                     $editedText = eregi_replace( $regExPrefix .
93                         $aBadWords[$i] .
94                         $regExSuffix, "\\1$replacement\\2", $editedText);
95                 }
96             }
97         }
98         return $editedText;
99     }
100
101     /**
102      * Defines the <CR><LF> value depending on the user OS.
103      *
104      * @return  string   the <CR><LF> value to use
105      * @access  public
106      */
107     function getCrlf()
108     {
109         SGL::logMessage(null, PEAR_LOG_DEBUG);
110
111         if (defined(PHP_EOL)) {
112             $crlf = PHP_EOL;
113         } elseif (defined('SGL_CLIENT_OS')) {
114             // Win case
115             if (SGL_CLIENT_OS == 'Win') {
116                 $crlf = "\r\n";
117             }
118             // Mac case
119             elseif (SGL_CLIENT_OS == 'Mac') {
120                 $crlf = "\r";
121             } else {
122                 $crlf = "\n";
123             }
124         } else {
125             $crlf = "\n";
126         }
127         return $crlf;
128     }
129
130     function trimWhitespace($var)
131     {
132         if (!is_array($var)) {
133             $clean = trim($var);
134         } else {
135             $clean = array_map(array('SGL_String', 'trimWhitespace'), $var);
136         }
137         return $clean;
138     }
139
140     /**
141      * If magic_quotes_gpc is in use, run stripslashes() on $var.
142      *
143      * @access  public
144      * @param   string $var  The string to un-quote, if necessary.
145      * @return  string       $var, minus any magic quotes.
146      * @author  Chuck Hagenbuch <chuck@horde.org>
147      */
148     function dispelMagicQuotes(&$var)
149     {
150         static $magicQuotes;
151         if (!isset($magicQuotes)) {
152             $magicQuotes = get_magic_quotes_gpc();
153         }
154         if ($magicQuotes) {
155             if (!is_array($var)) {
156                 $var = stripslashes($var);
157             } else {
158                 array_walk($var, array('SGL_String', 'dispelMagicQuotes'));
159             }
160         }
161     }
162
163     /**
164      * Returns cleaned user input.
165      *
166      * Instead of addslashing potential ' and " chars, let's remove them and get
167      * rid of any magic quoting which is enabled by default.  Also removes any
168      * html tags and ASCII zeros
169      *
170      * @access  public
171      * @param   string $var  The string to clean.
172      * @return  string       $cleaned result.
173      */
174     function clean($var)
175     {
176         if (isset($var)) {
177             if (!is_array($var)) {
178                 $clean = strip_tags($var);
179             } else {
180                 $clean = array_map(array('SGL_String', 'clean'), $var);
181             }
182             return SGL_String::trimWhitespace($clean);
183         } else {
184             return false;
185         }
186     }
187
188     function removeJs($var)
189     {
190         SGL::logMessage(null, PEAR_LOG_DEBUG);
191
192         if (isset($var)) {
193             if (!is_array($var)) {
194                 $search = "/<script[^>]*?>.*?<\/script\s*>/i";
195                 $replace = '';
196                 $clean = preg_replace($search, $replace, $var);
197             } else {
198                 $clean = array_map(array('SGL_String', 'removeJs'), $var);
199             }
200         }
201         return SGL_String::trimWhitespace($clean);
202     }
203
204     /**
205      * Uses PHP tidy lib (http://www.coggeshall.org/tidy.php) if enabled and
206      * extension is available. Cleans/corrects input html. If $logErrors
207      * is set to true and logging is set to true in default.conf.ini, tidy()
208      * will add entry to log with a string describing the errors and changes
209      * Tidy made via SGL::logMessage().
210      *
211      * @access public
212      * @param string $html the text to clean
213      * @param bool $logErrors
214      * @return string cleaned text
215      *
216      * @author  Andy Crain <andy@newslogic.com>
217      * @since   PHP 4.3
218      */
219     function tidy($html, $logErrors = false)
220     {
221         SGL::logMessage(null, PEAR_LOG_DEBUG);
222
223         $c = &SGL_Config::singleton();
224         $conf = $c->getAll();
225
226         if (       !$conf['site']['tidyhtml']
227                 || !extension_loaded('tidy')) {
228             return $html;
229         }
230         //  PHP5 version
231         if (SGL::isPhp5()) {
232             $options = array(
233                 'wrap' => 0,
234                 'indent' => true,
235                 'indent-spaces' => 4,
236                 'output-xhtml' => true,
237                 'drop-font-tags' => false,
238                 'clean' => false,
239             );
240             if (strlen($html)) {
241                 $tidy = new Tidy();
242                 $tidy->parseString($html, $options, 'utf8');
243                 $tidy->cleanRepair();
244                 $ret = $tidy->body();
245             }
246         //  PHP4 version
247         } else {
248             //  so we don't get doctype, html, head, body etc. tags added; default is false
249             tidy_setopt('show-body-only', true);
250             //  no wrapping of lines
251             tidy_setopt('wrap', 0);
252             tidy_setopt('indent', 1);
253             tidy_setopt('indent-spaces', 1);
254             tidy_parse_string($html);
255             if ((tidy_warning_count() || tidy_error_count()) && $logErrors) {
256                 SGL::logMessage('PHP Tidy error or warning: ' . tidy_get_error_buffer(), PEAR_LOG_NOTICE);
257             }
258             $ret = tidy_get_output();
259         }
260         return $ret;
261     }
262
263     /**
264      * Looks up key in current lang file (determined by preference)
265      * and returns target value.
266      *
267      * @param string $key       Translation term
268      * @param string $filter    Optional filter fn
269      * @return string
270      *
271      */
272     function translate($key, $filter = false, $aParams = array())
273     {
274         $c = &SGL_Config::singleton();
275         $conf = $c->getAll();
276
277         $trans = &$GLOBALS['_SGL']['TRANSLATION'];
278         if (isset($trans[$key])) {
279             if (!is_array($trans[$key])
280                     && strstr($trans[$key], '||')
281                     && $conf['translation']['container'] == 'db') {
282                 preg_match_all('/([^|]*)\|([^|]*)(?=\|\|)/', $trans[$key], $aPieces);
283                 $ret = array_combine($aPieces[1], $aPieces[2]);
284             } else {
285                 $ret = $trans[$key];
286             }
287             if (!is_array($trans[$key]) && $filter && function_exists($filter)) {
288                 if (!empty($aParams) && is_array($aParams) && $filter = 'vprintf') {
289                     $i = 1;
290                     foreach ($aParams as $key => $value) {
291                         $ret = str_replace("%$i", $value, $ret);
292                         $ret = str_replace("%$key", $value, $ret);
293                         $i++;
294                     }
295                     $ret = vsprintf($ret, $aParams);
296                 } else {
297                     $ret = $filter($ret);
298                 }
299             }
300             return $ret;
301         } else {
302             //  add translation
303             if (!empty($key)
304                     && isset($conf['translation']['addMissingTrans'])
305                     && $conf['translation']['addMissingTrans']
306                     && isset($conf['translation']['container'])
307                     && $conf['translation']['container'] == 'db') {
308
309                 //  get a reference to the request object
310                 $req = & SGL_Request::singleton();
311                 $moduleName = $req->get('moduleName');
312
313                 //  fetch fallback lang
314                 $fallbackLang = $conf['translation']['fallbackLang'];
315
316                 $trans = &SGL_Translation::singleton('admin');
317                 $result = $trans->add($key, $moduleName, array($fallbackLang => $key));
318             }
319
320             SGL::logMessage('Key \''.$key.'\' Not found', PEAR_LOG_NOTICE);
321
322             $key = (isset($conf['debug']['showUntranslated']) && $conf['debug']['showUntranslated'])
323                 ? '>' . $key . '<'
324                 : $key;
325             return $key;
326         }
327     }
328
329     /**
330      * Encode a given character to a decimal or hexadecimal HTML entity or
331      * to an hexadecimal URL-encoded symbol.
332      *
333      * @param string $char Char to encode
334      * @param mixed $encoding 1 or D for decimal entity, 2 or H for hexa entity,
335      *        3 or U for URL-encoding,
336      *        R for a random choice of any of the above,
337      *        E for a random choice of any of the HTML entities.
338      * @return string $encoded Encoded character (or raw char if unknown encoding)
339      *
340      * @author  Philippe Lhoste <PhiLho(a)GMX.net>
341      */
342     function char2entity($char, $encoding = 'H')
343     {
344         $pad = 1;
345         if ($encoding == 'R' || $encoding == 'E') {
346             // Use random padding with zeroes
347             // Unicode stops at 0x10FFFF, ie. at 1114111 (7 digits)
348             $pad = rand(2, 7);
349             if ($encoding == 'R') {
350                 // Full random
351                 $encoding = rand(1, 3);
352             } else {
353                 // Random only to entity
354                 $encoding = rand(1, 2);
355             }
356         }
357         $asc = ord($char);
358
359         switch ($encoding) {
360         case 1: // Decimal entity
361         case 'D':
362             return sprintf("&#%0{$pad}d;", $asc);
363             break;
364         case 2: // Hexadecimal entity
365         case 'H':
366             return sprintf("&#x%0{$pad}X;", $asc);
367             break;
368         case 3: // URL-encoding
369         case 'U':
370             return sprintf("%%%02X", $asc);
371             break;
372         default:
373             return $char;
374         }
375     }
376
377     /**
378      * Primarily used for obfuscating email addresses to prevent spam
379      * harvesting. Since it is URL-encoded, this can be used only in the href
380      * part of a <a> tag (mailto: scheme).
381      *
382      * @param string $str String to encode
383      * @return string $encoded Encoded string
384      */
385     function obfuscate($str)
386     {
387         $encoded = bin2hex($str);
388         $encoded = chunk_split($encoded, 2, '%');
389         $encoded = '%' . substr($encoded, 0, strlen($encoded) - 1);
390         return $encoded;
391     }
392
393     /**
394      * Primarily used for obfuscating email addresses to prevent spam
395      * harvesting.
396      *
397      * @param string $str String to encode
398      * @param bool $bForLink true if used in the href part of a <a> tag, false to be used in HTML
399      * @return string $encoded Encoded string
400      *
401      * @author  Philippe Lhoste <PhiLho(a)GMX.net>
402      */
403     function obfuscate2($str, $bForLink = true)
404     {
405         if ($bForLink) {
406             $e = "'R'";
407         } else {
408             $e = "'E'";
409         }
410         $encoded = preg_replace_callback(
411                 '|([-?=@._emailto:])|', // Mostly arbitrary, to mix encoded and unencoded chars...
412                 create_function(
413                         '$matches',
414                         "return char2entity(\$matches[0], $e);"
415                 ),
416                 $str
417         );
418         return $encoded;
419      }
420
421     /**
422      * Lightweight function to obfuscate mail addresses: substitutes @ and dots
423      * in the domain part with a string.
424      *
425      * @access  public
426      * @param   string $address
427      * @return  string
428      *
429      * @author Riccardo Magliocchetti <riccardo@datahost.it>
430      */
431     function obfuscate3($address)
432     {
433         $at = '(at)';
434         $dot = '(dot)';
435
436         $len = strlen($address);
437         $pos = strpos($address, '@');
438         $name = substr($address, 0, $pos-$len);
439
440         /* Trick to avoid the regex */
441         $domain = $at . substr($address, $pos+1);
442         $domain = preg_replace('/\./', $dot, $domain);
443
444         return $name . $domain;
445     }
446
447     /**
448      * Munge email addresses swapping plain text with html char entities as
449      * explained here: http://perso.crans.org/~raffo/aem/index.php.
450      *
451      * @access  public
452      * @param   string $address
453      * @return  string
454      *
455      * @author Riccardo Magliocchetti <riccardo@datahost.it>
456      */
457     function mungeMailAddress($address)
458     {
459         $len = strlen($address);
460         $aOld = str_split($address);
461         $aMunged = array();
462
463         for ($i = 0; $i < $len; $i++) {
464             $aMunged[$i] =  "&#" . ord($aOld[$i]) . ";";
465         }
466
467         $munged = implode('' ,$aMunged);
468
469         return $munged;
470     }
471
472     /**
473      * Returns a shortened version of text string resolved by word boundaries.
474      *
475      * @access  public
476      * @param   string  $str    Text to be shortened
477      * @param   integer $limit  Number of words/chars to cut to
478      * @param   integer $element What string element type to count by
479      * @param   string  $appendString  Trailing string to be appended
480      * @return  string  $processedString    Correctly shortened text
481      */
482     function summarise($str, $limit=50, $element = SGL_WORD, $appendString=' ...')
483     {
484         switch ($element) {
485         case SGL_CHAR:
486             $ret = (strlen($str) > $limit) ? substr($str, 0, $limit) . $appendString : $str;
487             break;
488
489         case SGL_WORD:
490             $limit--;
491             $words = explode(' ', $str);
492             $sliced = (count($words) > $limit) ? array_slice($words, 0, $limit) : $words;
493             $ret = implode(' ', $sliced);
494             $ret = (count($words) > $limit) ? $ret . $appendString : $ret;
495             break;
496         }
497         return  $ret;
498     }
499
500     /**
501      * Returns a set number of lines of a block of html, for summarising articles.
502      *
503      * @param string $str
504      * @param integer $lines
505      * @param string $appendString
506      * @return string
507      * @todo    needs to handle orphan <b> and <strong> tags
508      */
509     function summariseHtml($str, $lines=10)
510     {
511         $aLines = explode("\n", $str);
512         $aSegment = array_slice($aLines, 0, $lines);
513
514         //  close tags like <ul> so page layout doesn't break
515         $unclosedListTags = 0;
516         $aMatches = array();
517         foreach ($aSegment as $line) {
518             if (preg_match("/<[u|o]l/i", $line, $matches)) {
519                 $aMatches[] = $matches;
520                 $unclosedListTags++;
521             }
522             if (preg_match("/<\/[u|o]l>/i", $line)) {
523                 $unclosedListTags--;
524             }
525         }
526         //  reinstate close tags
527         for ($x=0; $x < $unclosedListTags; $x++) {
528             array_push($aSegment, '</ul>');
529         }
530         $ret = implode("\n", $aSegment);
531         $ret = SGL_String::tidy($ret);
532         return $ret;
533     }
534
535     /**
536      * Converts bytes to KB/MB/GB as appropriate.
537      *
538      * @access  public
539      * @param   int $bytes
540      * @return  int B/KB/MB/GB
541      */
542      function formatBytes($size, $decimals = 1, $lang = '--')
543     {
544         $aSizeList = array(1073741824, 1048576, 1024, 0);
545         // Should check if string is in an array, other languages may use octets
546         if ($lang == 'FR') {
547             $aSizeNameList = array(' Go', ' Mo', ' Ko', ' octets');
548             // Note: should also use French decimal separator (coma)
549         } else {
550             $aSizeNameList = array('GB', 'MB', 'KB', 'B');
551         }
552         $i = 0;
553         foreach ($aSizeList as $bytes) {
554             if ($size >= $bytes) {
555                 if ($bytes == 0) {
556                     // size 0 override
557                     $bytes = 1;
558                     $decimals = 0;
559                 }
560                 $formated = sprintf("%.{$decimals}f{$aSizeNameList[$i]}", $size / $bytes);
561                 break;
562             }
563             $i++;
564         }
565         return $formated;
566     }
567
568     function toValidVariableName($str)
569     {
570         //  remove illegal chars
571         $search = '/[^a-zA-Z1-9_]/';
572         $replace = '';
573         $res = preg_replace($search, $replace, $str);
574         //  ensure 1st letter is lc
575         $firstLetter = strtolower($res[0]);
576         $final = substr_replace($res, $firstLetter, 0, 1);
577         return $final;
578     }
579
580     function toValidFileName($origName)
581     {
582         return SGL_String::dirify($origName);
583     }
584
585     //  from http://kalsey.com/2004/07/dirify_in_php/
586     function dirify($s)
587     {
588          $s = SGL_String::convertHighAscii($s);     ## convert high-ASCII chars to 7bit.
589          $s = strtolower($s);                       ## lower-case.
590          $s = strip_tags($s);                       ## remove HTML tags.
591          // Note that   (for example) is legal in HTML 4, ie. semi-colon is optional if it is followed
592          // by a non-alphanumeric character (eg. space, tag...).
593 //         $s = preg_replace('!&[^;\s]+;!','',$s);    ## remove HTML entities.
594          $s = preg_replace('!&#?[A-Za-z0-9]{1,7};?!', '', $s);    ## remove HTML entities.
595          $s = preg_replace('![^\w\s-]!', '',$s);    ## remove non-word/space chars.
596          $s = preg_replace('!\s+!', '_',$s);        ## change space chars to underscores.
597          return $s;
598     }
599
600     function convertHighAscii($s)
601     {
602         // Seems to be for Latin-1 (ISO-8859-1) and quite limited (no ae/oe, no y:/Y:, etc.)
603          $aHighAscii = array(
604            "!\xc0!" => 'A',    # A`
605            "!\xe0!" => 'a',    # a`
606            "!\xc1!" => 'A',    # A'
607            "!\xe1!" => 'a',    # a'
608            "!\xc2!" => 'A',    # A^
609            "!\xe2!" => 'a',    # a^
610            "!\xc4!" => 'A',    # A:
611            "!\xe4!" => 'a',    # a:
612            "!\xc3!" => 'A',    # A~
613            "!\xe3!" => 'a',    # a~
614            "!\xc8!" => 'E',    # E`
615            "!\xe8!" => 'e',    # e`
616            "!\xc9!" => 'E',    # E'
617            "!\xe9!" => 'e',    # e'
618            "!\xca!" => 'E',    # E^
619            "!\xea!" => 'e',    # e^
620            "!\xcb!" => 'E',    # E:
621            "!\xeb!" => 'e',    # e:
622            "!\xcc!" => 'I',    # I`
623            "!\xec!" => 'i',    # i`
624            "!\xcd!" => 'I',    # I'
625            "!\xed!" => 'i',    # i'
626            "!\xce!" => 'I',    # I^
627            "!\xee!" => 'i',    # i^
628            "!\xcf!" => 'I',    # I:
629            "!\xef!" => 'i',    # i:
630            "!\xd2!" => 'O',    # O`
631            "!\xf2!" => 'o',    # o`
632            "!\xd3!" => 'O',    # O'
633            "!\xf3!" => 'o',    # o'
634            "!\xd4!" => 'O',    # O^
635            "!\xf4!" => 'o',    # o^
636            "!\xd6!" => 'O',    # O:
637            "!\xf6!" => 'o',    # o:
638            "!\xd5!" => 'O',    # O~
639            "!\xf5!" => 'o',    # o~
640            "!\xd8!" => 'O',    # O/
641            "!\xf8!" => 'o',    # o/
642            "!\xd9!" => 'U',    # U`
643            "!\xf9!" => 'u',    # u`
644            "!\xda!" => 'U',    # U'
645            "!\xfa!" => 'u',    # u'
646            "!\xdb!" => 'U',    # U^
647            "!\xfb!" => 'u',    # u^
648            "!\xdc!" => 'U',    # U:
649            "!\xfc!" => 'u',    # u:
650            "!\xc7!" => 'C',    # ,C
651            "!\xe7!" => 'c',    # ,c
652            "!\xd1!" => 'N',    # N~
653            "!\xf1!" => 'n',    # n~
654            "!\xdf!" => 'ss'
655          );
656          $find = array_keys($aHighAscii);
657          $replace = array_values($aHighAscii);
658          $s = preg_replace($find, $replace, $s);
659          return $s;
660     }
661
662     /**
663      * Removes chars that are illegal in ini files.
664      *
665      * @param string $string
666      * @return string
667      */
668     function stripIniFileIllegalChars($string)
669     {
670         return preg_replace("/[\|\&\~\!\"\(\)]/i", "", $string);
671     }
672
673     /**
674      * Converts strings representing constants to int values.
675      *
676      * Used for when constants are stored as strings in config.
677      *
678      * @static
679      * @param string $string
680      * @return integer
681      */
682     function pseudoConstantToInt($string)
683     {
684         $ret = 0;
685         if (is_int($string)) {
686             $ret = $string;
687         }
688         if (is_numeric($string)) {
689             $ret = (int)$string;
690         }
691         if (SGL_Inflector::isConstant($string)) {
692             $const = str_replace("'", '', $string);
693             if (defined($const)) {
694                 $ret = constant($const);
695             }
696         }
697         return $ret;
698     }
699 }
700
701 if (!function_exists('array_combine')) {
702     function array_combine($a, $b)
703     {
704         $c = array();
705         if (is_array($a) && is_array($b))
706             while (list(, $va) = each($a))
707                 if (list(, $vb) = each($b)) {
708                     $c[$va] = $vb;
709                 } else {
710                     break 1;
711                 }
712         return $c;
713     }
714 }
715 ?>
716
Note: See TracBrowser for help on using the browser.